Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
feat: support for federated credentials for workflow automation (#2769)
Kyle Mendell818d30682388
diff --git a/.vscode/settings.json b/.vscode/settings.jsonindex 3807e1817..6c72a52a5 100644--- a/.vscode/settings.json+++ b/.vscode/settings.json@@ -6,11 +6,11 @@"scminput": false,"typescript": true},- "typescript.tsdk": "frontend/node_modules/typescript/lib","go.buildTags": "playwright,buildables","prettier.documentSelectors": ["**/*.svelte"],"tasks.statusbar.default.hide": true,"tasks.statusbar.limit": 8,"github.copilot.chat.summarizeAgentConversationHistory.enabled": false,- "snyk.advanced.autoSelectOrganization": false+ "snyk.advanced.autoSelectOrganization": false,+ "js/ts.tsdk.path": "frontend/node_modules/typescript/lib"}diff --git a/backend/api/api.go b/backend/api/api.goindex 131fbdc84..0be9a4a0d 100644--- a/backend/api/api.go+++ b/backend/api/api.go@@ -144,6 +144,7 @@ type Services struct {Auth *services.AuthServiceOidc *services.OidcServiceApiKey *services.ApiKeyService+ Federated *services.FederatedCredentialServiceAppImages *services.ApplicationImagesServiceProject *services.ProjectServiceEvent *services.EventService@@ -317,6 +318,7 @@ func registerHandlers(api huma.API, svc *Services) {var authSvc *services.AuthServicevar oidcSvc *services.OidcServicevar apiKeySvc *services.ApiKeyService+ var federatedSvc *services.FederatedCredentialServicevar appImagesSvc *services.ApplicationImagesServicevar projectSvc *services.ProjectServicevar eventSvc *services.EventService@@ -358,6 +360,7 @@ func registerHandlers(api huma.API, svc *Services) {authSvc = svc.AuthoidcSvc = svc.OidcapiKeySvc = svc.ApiKey+ federatedSvc = svc.FederatedappImagesSvc = svc.AppImagesprojectSvc = svc.ProjecteventSvc = svc.Event@@ -396,6 +399,7 @@ func registerHandlers(api huma.API, svc *Services) {handlers.RegisterHealth(api)handlers.RegisterAuth(api, userSvc, authSvc, oidcSvc)handlers.RegisterApiKeys(api, apiKeySvc)+ handlers.RegisterFederatedCredentials(api, federatedSvc)handlers.RegisterRoles(api, roleSvc)handlers.RegisterAppImages(api, appImagesSvc)handlers.RegisterUsers(api, userSvc, authSvc)diff --git a/backend/api/handlers/federated.go b/backend/api/handlers/federated.gonew file mode 100644index 000000000..3e6c6bec9--- /dev/null+++ b/backend/api/handlers/federated.go@@ -0,0 +1,335 @@+package handlers++import (+ "context"+ "net/http"++ "github.com/danielgtaylor/huma/v2"+ humamw "github.com/getarcaneapp/arcane/backend/api/middleware"+ "github.com/getarcaneapp/arcane/backend/internal/common"+ "github.com/getarcaneapp/arcane/backend/internal/services"+ "github.com/getarcaneapp/arcane/backend/pkg/authz"+ "github.com/getarcaneapp/arcane/backend/pkg/pagination"+ "github.com/getarcaneapp/arcane/types/base"+ federatedtypes "github.com/getarcaneapp/arcane/types/federated"+ "github.com/labstack/echo/v4"+)++// FederatedCredentialHandler provides Huma-based federated credential+// management endpoints.+type FederatedCredentialHandler struct {+ federatedCredentialService *services.FederatedCredentialService+}++type federatedTokenExchangeError struct {+ Error string `json:"error"` //nolint:tagliatelle // RFC 6749 wire shape is snake_case.+ ErrorDescription string `json:"error_description,omitempty"` //nolint:tagliatelle // RFC 6749 wire shape is snake_case.+}++type ListFederatedCredentialsInput struct {+ Search string `query:"search" doc:"Search query for filtering by name, issuer, or subject"`+ Sort string `query:"sort" doc:"Column to sort by"`+ Order string `query:"order" default:"asc" doc:"Sort direction (asc or desc)"`+ Start int `query:"start" default:"0" doc:"Start index for pagination"`+ Limit int `query:"limit" default:"20" doc:"Number of items per page"`+}++type ListFederatedCredentialsOutput struct {+ Body base.Paginated[federatedtypes.FederatedCredential]+}++type CreateFederatedCredentialInput struct {+ Body federatedtypes.CreateFederatedCredential+}++type CreateFederatedCredentialOutput struct {+ Body base.ApiResponse[federatedtypes.FederatedCredential]+}++type GetFederatedCredentialInput struct {+ ID string `path:"id" doc:"Federated credential ID"`+}++type GetFederatedCredentialOutput struct {+ Body base.ApiResponse[federatedtypes.FederatedCredential]+}++type UpdateFederatedCredentialInput struct {+ ID string `path:"id" doc:"Federated credential ID"`+ Body federatedtypes.UpdateFederatedCredential+}++type UpdateFederatedCredentialOutput struct {+ Body base.ApiResponse[federatedtypes.FederatedCredential]+}++type DeleteFederatedCredentialInput struct {+ ID string `path:"id" doc:"Federated credential ID"`+}++type DeleteFederatedCredentialOutput struct {+ Body base.ApiResponse[base.MessageResponse]+}++// RegisterFederatedTokenExchange registers the public RFC 8693 token exchange+// endpoint. It intentionally uses Echo because the standard requires form+// encoding while the rest of Arcane's Huma API is JSON-first.+func RegisterFederatedTokenExchange(g *echo.Group, federatedCredentialService *services.FederatedCredentialService) {+ g.POST("/auth/federated/token", func(c echo.Context) error {+ if federatedCredentialService == nil {+ return c.JSON(http.StatusInternalServerError, federatedTokenExchangeError{+ Error: "server_error",+ ErrorDescription: "service not available",+ })+ }+ if err := c.Request().ParseForm(); err != nil {+ return c.JSON(http.StatusBadRequest, federatedTokenExchangeError{+ Error: "invalid_request",+ ErrorDescription: "invalid token exchange request",+ })+ }++ form := c.Request().Form+ resp, err := federatedCredentialService.ExchangeToken(c.Request().Context(), federatedtypes.TokenExchangeRequest{+ GrantType: form.Get("grant_type"),+ SubjectToken: form.Get("subject_token"),+ SubjectTokenType: form.Get("subject_token_type"),+ Audience: form.Get("audience"),+ Scope: form.Get("scope"),+ RequestedTokenType: form.Get("requested_token_type"),+ })+ if err != nil {+ return writeFederatedTokenExchangeErrorInternal(c, err)+ }+ return c.JSON(http.StatusOK, resp)+ })+}++// RegisterFederatedCredentials registers federated credential management routes.+func RegisterFederatedCredentials(api huma.API, federatedCredentialService *services.FederatedCredentialService) {+ h := &FederatedCredentialHandler{+ federatedCredentialService: federatedCredentialService,+ }++ huma.Register(api, huma.Operation{+ OperationID: "list-federated-credentials",+ Method: http.MethodGet,+ Path: "/federated-credentials",+ Summary: "List federated credentials",+ Description: "Get a paginated list of workload identity federation trust rules",+ Tags: []string{"Federated Credentials"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: humamw.RequirePermission(api, authz.PermFederatedList),+ }, h.ListFederatedCredentials)++ huma.Register(api, huma.Operation{+ OperationID: "create-federated-credential",+ Method: http.MethodPost,+ Path: "/federated-credentials",+ Summary: "Create a federated credential",+ Description: "Create a workload identity federation trust rule",+ Tags: []string{"Federated Credentials"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: humamw.RequireGlobalAdmin(api),+ }, h.CreateFederatedCredential)++ huma.Register(api, huma.Operation{+ OperationID: "get-federated-credential",+ Method: http.MethodGet,+ Path: "/federated-credentials/{id}",+ Summary: "Get a federated credential",+ Description: "Get details of a workload identity federation trust rule",+ Tags: []string{"Federated Credentials"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: humamw.RequirePermission(api, authz.PermFederatedRead),+ }, h.GetFederatedCredential)++ huma.Register(api, huma.Operation{+ OperationID: "update-federated-credential",+ Method: http.MethodPut,+ Path: "/federated-credentials/{id}",+ Summary: "Update a federated credential",+ Description: "Update a workload identity federation trust rule",+ Tags: []string{"Federated Credentials"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: humamw.RequireGlobalAdmin(api),+ }, h.UpdateFederatedCredential)++ huma.Register(api, huma.Operation{+ OperationID: "delete-federated-credential",+ Method: http.MethodDelete,+ Path: "/federated-credentials/{id}",+ Summary: "Delete a federated credential",+ Description: "Delete a workload identity federation trust rule and its service user",+ Tags: []string{"Federated Credentials"},+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: humamw.RequireGlobalAdmin(api),+ }, h.DeleteFederatedCredential)+}++func (h *FederatedCredentialHandler) ListFederatedCredentials(ctx context.Context, input *ListFederatedCredentialsInput) (*ListFederatedCredentialsOutput, error) {+ if h.federatedCredentialService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }++ credentials, paginationResp, err := h.federatedCredentialService.List(ctx, pagination.QueryParams{+ SearchQuery: pagination.SearchQuery{Search: input.Search},+ SortParams: pagination.SortParams{+ Sort: input.Sort,+ Order: pagination.SortOrder(input.Order),+ },+ PaginationParams: pagination.PaginationParams{+ Start: input.Start,+ Limit: input.Limit,+ },+ })+ if err != nil {+ return nil, huma.Error500InternalServerError("failed to list federated credentials")+ }++ return &ListFederatedCredentialsOutput{+ Body: base.Paginated[federatedtypes.FederatedCredential]{+ Success: true,+ Data: credentials,+ Pagination: base.PaginationResponse{+ TotalPages: paginationResp.TotalPages,+ TotalItems: paginationResp.TotalItems,+ CurrentPage: paginationResp.CurrentPage,+ ItemsPerPage: paginationResp.ItemsPerPage,+ GrandTotalItems: paginationResp.GrandTotalItems,+ },+ },+ }, nil+}++func (h *FederatedCredentialHandler) CreateFederatedCredential(ctx context.Context, input *CreateFederatedCredentialInput) (*CreateFederatedCredentialOutput, error) {+ if h.federatedCredentialService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ credential, err := h.federatedCredentialService.Create(ctx, user.ID, input.Body)+ if err != nil {+ return nil, federatedCredentialManagementErrorInternal(err)+ }++ return &CreateFederatedCredentialOutput{+ Body: base.ApiResponse[federatedtypes.FederatedCredential]{+ Success: true,+ Data: *credential,+ },+ }, nil+}++func (h *FederatedCredentialHandler) GetFederatedCredential(ctx context.Context, input *GetFederatedCredentialInput) (*GetFederatedCredentialOutput, error) {+ if h.federatedCredentialService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ credential, err := h.federatedCredentialService.Get(ctx, input.ID)+ if err != nil {+ return nil, federatedCredentialManagementErrorInternal(err)+ }++ return &GetFederatedCredentialOutput{+ Body: base.ApiResponse[federatedtypes.FederatedCredential]{+ Success: true,+ Data: *credential,+ },+ }, nil+}++func (h *FederatedCredentialHandler) UpdateFederatedCredential(ctx context.Context, input *UpdateFederatedCredentialInput) (*UpdateFederatedCredentialOutput, error) {+ if h.federatedCredentialService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ user, exists := humamw.GetCurrentUserFromContext(ctx)+ if !exists {+ return nil, huma.Error401Unauthorized((&common.NotAuthenticatedError{}).Error())+ }++ credential, err := h.federatedCredentialService.Update(ctx, user.ID, input.ID, input.Body)+ if err != nil {+ return nil, federatedCredentialManagementErrorInternal(err)+ }++ return &UpdateFederatedCredentialOutput{+ Body: base.ApiResponse[federatedtypes.FederatedCredential]{+ Success: true,+ Data: *credential,+ },+ }, nil+}++func (h *FederatedCredentialHandler) DeleteFederatedCredential(ctx context.Context, input *DeleteFederatedCredentialInput) (*DeleteFederatedCredentialOutput, error) {+ if h.federatedCredentialService == nil {+ return nil, huma.Error500InternalServerError("service not available")+ }+ if err := h.federatedCredentialService.Delete(ctx, input.ID); err != nil {+ return nil, federatedCredentialManagementErrorInternal(err)+ }++ return &DeleteFederatedCredentialOutput{+ Body: base.ApiResponse[base.MessageResponse]{+ Success: true,+ Data: base.MessageResponse{+ Message: "Federated credential deleted successfully",+ },+ },+ }, nil+}++func writeFederatedTokenExchangeErrorInternal(c echo.Context, err error) error {+ var code string+ description := "token exchange rejected"++ switch {+ case common.IsErrorFederatedCredentialInvalidRequest(err):+ code = "invalid_request"+ description = "invalid token exchange request"+ case common.IsErrorFederatedCredentialInvalidGrant(err),+ common.IsErrorFederatedCredentialNotFound(err):+ code = "invalid_grant"+ case common.IsErrorFederatedCredentialInvalid(err):+ code = "invalid_request"+ default:+ code = "server_error"+ description = "token exchange failed"+ }++ return c.JSON(http.StatusBadRequest, federatedTokenExchangeError{+ Error: code,+ ErrorDescription: description,+ })+}++func federatedCredentialManagementErrorInternal(err error) error {+ switch {+ case common.IsErrorFederatedCredentialNotFound(err):+ return huma.Error404NotFound("federated credential not found")+ case common.IsErrorFederatedCredentialInvalid(err),+ common.IsErrorFederatedCredentialInvalidRequest(err):+ return huma.Error400BadRequest("invalid federated credential")+ case common.IsErrorFederatedCredentialPermissionEscalation(err):+ return huma.Error403Forbidden("permission denied")+ default:+ return huma.Error500InternalServerError("federated credential operation failed")+ }+}diff --git a/backend/api/playwright.go b/backend/api/playwright.goindex ee2f0b828..b1780fd6f 100644--- a/backend/api/playwright.go+++ b/backend/api/playwright.go@@ -24,12 +24,21 @@ func SetupPlaywrightRoutes(api *echo.Group, playwrightService *services.Playwrigplaywright.POST("/create-test-api-keys", playwrightHandler.CreateTestApiKeysHandler)playwright.POST("/delete-test-api-keys", playwrightHandler.DeleteTestApiKeysHandler)+ playwright.POST("/create-test-federated-credential", playwrightHandler.CreateTestFederatedCredentialHandler)}type CreateTestApiKeysRequest struct {Count int `json:"count"`}+type CreateTestFederatedCredentialRequest struct {+ IssuerURL string `json:"issuerUrl"`+ Audiences []string `json:"audiences"`+ Subject string `json:"subject"`+ RoleID string `json:"roleId"`+ TokenTTLSeconds int `json:"tokenTtlSeconds"`+}+func (ph *PlaywrightHandler) CreateTestApiKeysHandler(c echo.Context) error {var req CreateTestApiKeysRequestif err := c.Bind(&req); err != nil {@@ -55,3 +64,24 @@ func (ph *PlaywrightHandler) DeleteTestApiKeysHandler(c echo.Context) error {return c.NoContent(http.StatusNoContent)}++func (ph *PlaywrightHandler) CreateTestFederatedCredentialHandler(c echo.Context) error {+ var req CreateTestFederatedCredentialRequest+ if err := c.Bind(&req); err != nil {+ return c.JSON(http.StatusBadRequest, map[string]any{"error": "invalid request body"})+ }++ credentialID, err := ph.PlaywrightService.CreateTestFederatedCredential(+ c.Request().Context(),+ req.IssuerURL,+ req.Audiences,+ req.Subject,+ req.RoleID,+ req.TokenTTLSeconds,+ )+ if err != nil {+ return c.JSON(http.StatusInternalServerError, map[string]any{"error": err.Error()})+ }++ return c.JSON(http.StatusCreated, map[string]any{"credential": map[string]string{"id": credentialID}})+}diff --git a/backend/internal/bootstrap/playwright_router_bootstrap.go b/backend/internal/bootstrap/playwright_router_bootstrap.goindex 57629c65b..94d1cf410 100644--- a/backend/internal/bootstrap/playwright_router_bootstrap.go+++ b/backend/internal/bootstrap/playwright_router_bootstrap.go@@ -13,7 +13,7 @@ import (func init() {registerPlaywrightRoutes = []func(apiGroup *echo.Group, services *Services){func(apiGroup *echo.Group, svc *Services) {- playwrightService := services.NewPlaywrightService(svc.ApiKey, svc.User)+ playwrightService := services.NewPlaywrightService(svc.ApiKey, svc.User, svc.Federated)if playwrightService == nil {slog.Warn("Playwright service not available, skipping playwright routes")returndiff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.goindex 081551169..9bf7b6fa0 100644--- a/backend/internal/bootstrap/router_bootstrap.go+++ b/backend/internal/bootstrap/router_bootstrap.go@@ -158,6 +158,9 @@ func setupRouter(ctx context.Context, cfg *config.Config, appServices *Services)"/api/oidc/callback",}, 5, 5,))+ apiGroup.Use(middleware.PerIPRateLimitForPaths(+ []string{"/api/auth/federated/token"}, 10, 10,+ ))apiGroup.Use(middleware.PerIPRateLimitForPaths([]string{"/api/webhooks/trigger/:token"}, 60, 10,))@@ -175,6 +178,7 @@ func setupRouter(ctx context.Context, cfg *config.Config, appServices *Services)// Register public webhook trigger endpoint before auth middleware (token in URL is the sole auth)api.RegisterWebhookTrigger(apiGroup, appServices.Webhook, handlerAppCtx) //nolint:contextcheck // app lifecycle context is intentionally wrapped for detached activity work.+ handlers.RegisterFederatedTokenExchange(apiGroup, appServices.Federated) //nolint:contextcheck // public RFC 8693 form endpoint uses request context.//nolint:contextcheck // Echo middleware reads context from echo.Context.Request().Context(), not a parameter.envProxyMiddleware := middleware.NewEnvProxyMiddlewareWithParam(@@ -191,6 +195,7 @@ func setupRouter(ctx context.Context, cfg *config.Config, appServices *Services)Auth: appServices.Auth,Oidc: appServices.Oidc,ApiKey: appServices.ApiKey,+ Federated: appServices.Federated,AppImages: appServices.AppImages,Project: appServices.Project,Event: appServices.Event,diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.goindex ec9899c10..76463db63 100644--- a/backend/internal/bootstrap/services_bootstrap.go+++ b/backend/internal/bootstrap/services_bootstrap.go@@ -44,6 +44,7 @@ type Services struct {Version *services.VersionServiceNotification *services.NotificationServiceApiKey *services.ApiKeyService+ Federated *services.FederatedCredentialServiceGitRepository *services.GitRepositoryServiceGitOpsSync *services.GitOpsSyncServiceWebhook *services.WebhookService@@ -104,6 +105,7 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Configsvcs.Template = services.NewTemplateService(ctx, db, httpClient, svcs.Settings)svcs.Auth = services.NewAuthService(svcs.User, svcs.Settings, svcs.Event, svcs.Session, svcs.Role, cfg.JWTSecret, cfg)svcs.Oidc = services.NewOidcService(svcs.Auth, svcs.Settings, cfg, httpClient)+ svcs.Federated = services.NewFederatedCredentialService(db, svcs.Auth, svcs.User, svcs.Settings, svcs.Event, httpClient).WithRoleService(svcs.Role)svcs.System = services.NewSystemService(db, svcs.Docker, svcs.Container, svcs.Image, svcs.Volume, svcs.Network, svcs.Settings, svcs.Activity)svcs.SystemUpgrade = services.NewSystemUpgradeService(svcs.Docker, svcs.Version, svcs.Event, svcs.Settings)svcs.Updater = services.NewUpdaterService(db, svcs.Settings, svcs.Docker, svcs.Project, svcs.ImageUpdate, svcs.ContainerRegistry, svcs.Event, svcs.Image, svcs.Notification, svcs.SystemUpgrade, svcs.Activity)diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.goindex 229148339..9f231fbd1 100644--- a/backend/internal/common/errors.go+++ b/backend/internal/common/errors.go@@ -1778,6 +1778,56 @@ func IsInvalidRoleAssignmentError(err error) bool {return isErrorTypeInternal[*InvalidRoleAssignmentError](err)}+type FederatedCredentialNotFoundError struct{}++func (e *FederatedCredentialNotFoundError) Error() string {+ return "federated credential not found"+}++func IsErrorFederatedCredentialNotFound(err error) bool {+ return isErrorTypeInternal[*FederatedCredentialNotFoundError](err)+}++type FederatedCredentialInvalidError struct{}++func (e *FederatedCredentialInvalidError) Error() string {+ return "invalid federated credential"+}++func IsErrorFederatedCredentialInvalid(err error) bool {+ return isErrorTypeInternal[*FederatedCredentialInvalidError](err)+}++type FederatedCredentialInvalidRequestError struct{}++func (e *FederatedCredentialInvalidRequestError) Error() string {+ return "invalid federated token exchange request"+}++func IsErrorFederatedCredentialInvalidRequest(err error) bool {+ return isErrorTypeInternal[*FederatedCredentialInvalidRequestError](err)+}++type FederatedCredentialInvalidGrantError struct{}++func (e *FederatedCredentialInvalidGrantError) Error() string {+ return "invalid federated token grant"+}++func IsErrorFederatedCredentialInvalidGrant(err error) bool {+ return isErrorTypeInternal[*FederatedCredentialInvalidGrantError](err)+}++type FederatedCredentialPermissionEscalationError struct{}++func (e *FederatedCredentialPermissionEscalationError) Error() string {+ return "cannot map a federated credential to a role you do not hold"+}++func IsErrorFederatedCredentialPermissionEscalation(err error) bool {+ return isErrorTypeInternal[*FederatedCredentialPermissionEscalationError](err)+}+type OidcMappingNotFoundError struct{}func (e *OidcMappingNotFoundError) Error() string {diff --git a/backend/internal/models/event.go b/backend/internal/models/event.goindex a00f84083..09a0703f2 100644--- a/backend/internal/models/event.go+++ b/backend/internal/models/event.go@@ -66,11 +66,12 @@ const (EventTypeNetworkDelete EventType = "network.delete"EventTypeNetworkError EventType = "network.error"- EventTypeSystemPrune EventType = "system.prune"- EventTypeUserLogin EventType = "user.login"- EventTypeUserLogout EventType = "user.logout"- EventTypeSystemAutoUpdate EventType = "system.auto_update"- EventTypeSystemUpgrade EventType = "system.upgrade"+ EventTypeSystemPrune EventType = "system.prune"+ EventTypeUserLogin EventType = "user.login"+ EventTypeUserLogout EventType = "user.logout"+ EventTypeFederatedExchange EventType = "federated.exchange"+ EventTypeSystemAutoUpdate EventType = "system.auto_update"+ EventTypeSystemUpgrade EventType = "system.upgrade"EventTypeEnvironmentCreate EventType = "environment.create"EventTypeEnvironmentConnect EventType = "environment.connect"diff --git a/backend/internal/models/federated_credential.go b/backend/internal/models/federated_credential.gonew file mode 100644index 000000000..ce57dd8df--- /dev/null+++ b/backend/internal/models/federated_credential.go@@ -0,0 +1,33 @@+package models++import "time"++const (+ FederatedCredentialMatchExact = "exact"+ FederatedCredentialMatchGlob = "glob"+)++type FederatedCredential struct {+ Name string `json:"name" gorm:"column:name;not null" sortable:"true"`+ Description *string `json:"description,omitempty" gorm:"column:description"`+ Enabled bool `json:"enabled" gorm:"column:enabled;not null;default:false;index" sortable:"true"`+ IssuerURL string `json:"issuerUrl" gorm:"column:issuer_url;not null;index" sortable:"true"`+ Audiences StringSlice `json:"audiences" gorm:"column:audiences;type:text;not null"`+ SubjectClaim string `json:"subjectClaim" gorm:"column:subject_claim;not null;default:'sub'"`+ SubjectMatch string `json:"subjectMatch" gorm:"column:subject_match;not null"`+ MatchType string `json:"matchType" gorm:"column:match_type;not null;default:'exact'"`+ RoleID string `json:"roleId" gorm:"column:role_id;not null;index"`+ EnvironmentID *string `json:"environmentId,omitempty" gorm:"column:environment_id;index"`+ IdentityUserID string `json:"identityUserId" gorm:"column:identity_user_id;not null;index"`+ TokenTTLSeconds int `json:"tokenTtlSeconds" gorm:"column:token_ttl_seconds;not null;default:900"`+ LastUsedAt *time.Time `json:"lastUsedAt,omitempty" gorm:"column:last_used_at" sortable:"true"`+ ExpiresAt *time.Time `json:"expiresAt,omitempty" gorm:"column:expires_at" sortable:"true"`+ IdentityUser *User `json:"identityUser,omitempty" gorm:"foreignKey:IdentityUserID;constraint:OnDelete:CASCADE"`+ Role *Role `json:"role,omitempty" gorm:"foreignKey:RoleID;constraint:OnDelete:RESTRICT"`+ Environment *Environment `json:"environment,omitempty" gorm:"foreignKey:EnvironmentID;constraint:OnDelete:SET NULL"`+ BaseModel+}++func (FederatedCredential) TableName() string {+ return "federated_credentials"+}diff --git a/backend/internal/models/federated_token_replay.go b/backend/internal/models/federated_token_replay.gonew file mode 100644index 000000000..497f582f6--- /dev/null+++ b/backend/internal/models/federated_token_replay.go@@ -0,0 +1,14 @@+package models++import "time"++type FederatedTokenReplay struct {+ TokenHash string `json:"-" gorm:"column:token_hash;not null;uniqueIndex"`+ IssuerURL string `json:"issuerUrl" gorm:"column:issuer_url;not null;index"`+ ExpiresAt time.Time `json:"expiresAt" gorm:"column:expires_at;not null;index"`+ BaseModel+}++func (FederatedTokenReplay) TableName() string {+ return "federated_token_replays"+}diff --git a/backend/internal/models/settings.go b/backend/internal/models/settings.goindex 4731c55cd..cf7e3d652 100644--- a/backend/internal/models/settings.go+++ b/backend/internal/models/settings.go@@ -175,6 +175,8 @@ type Settings struct {// API Keys category (admin management page - no actual settings)ApiKeysCategoryPlaceholder SettingVariable `key:"apiKeysCategory,internal" meta:"label=API Keys;type=internal;keywords=api,keys,tokens,authentication,access,programmatic,integration;category=apikeys;description=Manage API keys for programmatic access" catmeta:"id=apikeys;title=API Keys;icon=apikey;url=/settings/api-keys;description=Create and manage API keys for programmatic access to Arcane"`+ FederatedCredentialsCategoryPlaceholder SettingVariable `key:"federatedCredentialsCategory,internal" meta:"label=Federated Credentials;type=internal;keywords=federated,credentials,workload,identity,oidc,token exchange,ci,github,gitlab;category=authentication;description=Manage workload identity federation credentials"`+// Webhooks category (management page - no actual settings)WebhooksCategoryPlaceholder SettingVariable `key:"webhooksCategory,internal" meta:"label=Webhooks;type=internal;keywords=webhooks,trigger,inbound,http,container,stack,gitops,updater,automation,ci,cd;category=webhooks;description=Manage inbound webhooks to trigger updates" catmeta:"id=webhooks;title=Webhooks;icon=globe;url=/settings/webhooks;description=Create and manage inbound webhooks to trigger container, stack, or GitOps updates"`diff --git a/backend/internal/models/user.go b/backend/internal/models/user.goindex 2669f53b9..10f54fea8 100644--- a/backend/internal/models/user.go+++ b/backend/internal/models/user.go@@ -13,6 +13,7 @@ type User struct {LastLogin *time.Time `json:"lastLogin,omitempty" gorm:"column:last_login" sortable:"true"`Locale *string `json:"locale,omitempty" gorm:"column:locale"`RequiresPasswordChange bool `json:"requiresPasswordChange" gorm:"column:requires_password_change"`+ IsServiceAccount bool `json:"isServiceAccount" gorm:"column:is_service_account;not null;default:false"`// OIDC provider tokensOidcAccessToken *string `json:"-" gorm:"type:text"`diff --git a/backend/internal/models/user_session.go b/backend/internal/models/user_session.goindex 3b6d155d7..086248baa 100644--- a/backend/internal/models/user_session.go+++ b/backend/internal/models/user_session.go@@ -2,16 +2,25 @@ package modelsimport "time"+const (+ UserSessionSourceLocal = "local"+ UserSessionSourceOidc = "oidc"+ UserSessionSourceFederated = "federated"+)+type UserSession struct {BaseModel- UserID string `json:"userId" gorm:"column:user_id;not null;index"`- User *User `json:"user,omitempty" gorm:"foreignKey:UserID;constraint:OnDelete:CASCADE"`- RefreshTokenHash string `json:"-" gorm:"column:refresh_token_hash;not null;uniqueIndex"`- UserAgent *string `json:"userAgent,omitempty" gorm:"column:user_agent"`- IPAddress *string `json:"ipAddress,omitempty" gorm:"column:ip_address"`- LastUsedAt time.Time `json:"lastUsedAt" gorm:"column:last_used_at;not null"`- ExpiresAt time.Time `json:"expiresAt" gorm:"column:expires_at;not null;index"`- RevokedAt *time.Time `json:"revokedAt,omitempty" gorm:"column:revoked_at"`+ UserID string `json:"userId" gorm:"column:user_id;not null;index"`+ User *User `json:"user,omitempty" gorm:"foreignKey:UserID;constraint:OnDelete:CASCADE"`+ RefreshTokenHash string `json:"-" gorm:"column:refresh_token_hash;not null;uniqueIndex"`+ UserAgent *string `json:"userAgent,omitempty" gorm:"column:user_agent"`+ IPAddress *string `json:"ipAddress,omitempty" gorm:"column:ip_address"`+ Source string `json:"source,omitempty" gorm:"column:source"`+ FederatedCredentialID *string `json:"federatedCredentialId,omitempty" gorm:"column:federated_credential_id;index"`+ FederatedCredential *FederatedCredential `json:"federatedCredential,omitempty" gorm:"foreignKey:FederatedCredentialID;constraint:OnDelete:SET NULL"`+ LastUsedAt time.Time `json:"lastUsedAt" gorm:"column:last_used_at;not null"`+ ExpiresAt time.Time `json:"expiresAt" gorm:"column:expires_at;not null;index"`+ RevokedAt *time.Time `json:"revokedAt,omitempty" gorm:"column:revoked_at"`}func (UserSession) TableName() string {diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.goindex 60e18e2d0..f086ce619 100644--- a/backend/internal/services/auth_service.go+++ b/backend/internal/services/auth_service.go@@ -45,12 +45,14 @@ type AuthSettings struct {type userClaims struct {jwt.RegisteredClaims- SessionID string `json:"sid,omitempty"`- UserID string `json:"user_id"`- Username string `json:"username"`- Email string `json:"email,omitempty"`- DisplayName string `json:"display_name,omitempty"`- AppVersion string `json:"app_version,omitempty"`+ SessionID string `json:"sid,omitempty"`+ UserID string `json:"user_id"`+ Username string `json:"username"`+ Email string `json:"email,omitempty"`+ DisplayName string `json:"display_name,omitempty"`+ AppVersion string `json:"app_version,omitempty"`+ TokenType string `json:"token_type,omitempty"`+ FederatedCredentialID string `json:"federated_credential_id,omitempty"`}type refreshClaims struct {@@ -893,6 +895,70 @@ func (s *AuthService) buildTokenPairInternal(ctx context.Context, user *models.U}, nil}+func (s *AuthService) IssueFederatedToken(ctx context.Context, user *models.User, credentialID string, ttlSeconds int) (*TokenPair, error) {+ if s.sessionService == nil {+ return nil, &common.SessionServiceUnavailableError{}+ }+ if user == nil {+ return nil, ErrUserNotFound+ }++ ttlSeconds = clampFederatedTokenTTLSecondsInternal(ttlSeconds)+ now := time.Now()+ accessTokenExpiry := now.Add(time.Duration(ttlSeconds) * time.Second)++ session, err := s.sessionService.CreateFederatedSession(ctx, user.ID, accessTokenExpiry, credentialID)+ if err != nil {+ return nil, err+ }++ claims := userClaims{+ RegisteredClaims: jwt.RegisteredClaims{+ ID: user.ID,+ Subject: "access",+ IssuedAt: jwt.NewNumericDate(now),+ ExpiresAt: jwt.NewNumericDate(accessTokenExpiry),+ },+ SessionID: session.ID,+ UserID: user.ID,+ Username: user.Username,+ AppVersion: config.Version,+ TokenType: models.UserSessionSourceFederated,+ FederatedCredentialID: credentialID,+ }++ if user.Email != nil {+ claims.Email = *user.Email+ }+ if user.DisplayName != nil {+ claims.DisplayName = *user.DisplayName+ }++ accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)+ accessTokenString, err := accessToken.SignedString(s.jwtSecret)+ if err != nil {+ return nil, err+ }++ return &TokenPair{+ AccessToken: accessTokenString,+ ExpiresAt: accessTokenExpiry,+ }, nil+}++func clampFederatedTokenTTLSecondsInternal(ttlSeconds int) int {+ if ttlSeconds <= 0 {+ return 900+ }+ if ttlSeconds < 60 {+ return 60+ }+ if ttlSeconds > 3600 {+ return 3600+ }+ return ttlSeconds+}+func validateSessionActiveInternal(session *models.UserSession) error {if session == nil {return ErrInvalidTokendiff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.goindex 3b8c06355..7f30f0c70 100644--- a/backend/internal/services/event_service.go+++ b/backend/internal/services/event_service.go@@ -636,8 +636,9 @@ var eventDefinitions = map[models.EventType]struct {models.EventTypeSystemAutoUpdate: {"System auto-update completed", "System auto-update process has completed", models.EventSeverityInfo},models.EventTypeSystemUpgrade: {"System upgrade completed", "System upgrade process has completed", models.EventSeverityInfo},- models.EventTypeUserLogin: {"User logged in: %s", "User '%s' has logged in", models.EventSeverityInfo},- models.EventTypeUserLogout: {"User logged out: %s", "User '%s' has logged out", models.EventSeverityInfo},+ models.EventTypeUserLogin: {"User logged in: %s", "User '%s' has logged in", models.EventSeverityInfo},+ models.EventTypeUserLogout: {"User logged out: %s", "User '%s' has logged out", models.EventSeverityInfo},+ models.EventTypeFederatedExchange: {"Federated credential exchange: %s", "Federated credential exchange for '%s'", models.EventSeverityInfo},}func (s *EventService) toEventDto(e *models.Event) *event.Event {diff --git a/backend/internal/services/federated_credential_service.go b/backend/internal/services/federated_credential_service.gonew file mode 100644index 000000000..9c0bce591--- /dev/null+++ b/backend/internal/services/federated_credential_service.go@@ -0,0 +1,873 @@+package services++import (+ "context"+ "crypto/sha256"+ "encoding/hex"+ "errors"+ "fmt"+ "log/slog"+ "net/http"+ "net/url"+ "regexp"+ "strings"+ "sync"+ "time"++ "github.com/coreos/go-oidc/v3/oidc"+ "github.com/google/uuid"+ "golang.org/x/sync/singleflight"+ "gorm.io/gorm"++ "github.com/getarcaneapp/arcane/backend/internal/common"+ "github.com/getarcaneapp/arcane/backend/internal/database"+ "github.com/getarcaneapp/arcane/backend/internal/models"+ "github.com/getarcaneapp/arcane/backend/pkg/pagination"+ pkgutils "github.com/getarcaneapp/arcane/backend/pkg/utils"+ "github.com/getarcaneapp/arcane/backend/pkg/utils/dbutil"+ "github.com/getarcaneapp/arcane/backend/pkg/utils/httpx"+ "github.com/getarcaneapp/arcane/backend/pkg/utils/jwtclaims"+ federatedtypes "github.com/getarcaneapp/arcane/types/federated"+)++const (+ federatedCredentialLastUsedWriteWindow = 5 * time.Minute+ defaultFederatedSubjectClaim = "sub"+)++type FederatedCredentialService struct {+ db *database.DB+ authService *AuthService+ userService *UserService+ settingsService *SettingsService+ eventService *EventService+ roleService *RoleService+ httpClient *http.Client+ providerMu sync.RWMutex+ providers map[string]*oidc.Provider+ providerGroup singleflight.Group+}++func NewFederatedCredentialService(+ db *database.DB,+ authService *AuthService,+ userService *UserService,+ settingsService *SettingsService,+ eventService *EventService,+ httpClient *http.Client,+) *FederatedCredentialService {+ if httpClient == nil {+ httpClient = httpx.NewHTTPClientWithTimeout(15 * time.Second)+ }++ return &FederatedCredentialService{+ db: db,+ authService: authService,+ userService: userService,+ settingsService: settingsService,+ eventService: eventService,+ httpClient: httpClient,+ providers: make(map[string]*oidc.Provider),+ }+}++func (s *FederatedCredentialService) WithRoleService(roleService *RoleService) *FederatedCredentialService {+ s.roleService = roleService+ return s+}++func (s *FederatedCredentialService) ExchangeToken(ctx context.Context, req federatedtypes.TokenExchangeRequest) (*federatedtypes.FederatedTokenResponse, error) {+ issuer, subject, audiences := unverifiedTokenExchangeMetadataInternal(req.SubjectToken)+ logResult := "failure"+ logReason := ""+ var matchedCredential *models.FederatedCredential+ var matchedUser *models.User+ defer func() {+ s.logExchangeInternal(ctx, logResult, logReason, issuer, subject, audiences, matchedCredential, matchedUser)+ }()++ if err := validateTokenExchangeRequestInternal(req); err != nil {+ logReason = "invalid_request"+ return nil, err+ }+ if issuer == "" {+ logReason = "missing_issuer"+ return nil, &common.FederatedCredentialInvalidGrantError{}+ }++ credentials, err := s.listEnabledCredentialsForIssuerInternal(ctx, issuer)+ if err != nil {+ logReason = "credential_lookup_failed"+ return nil, err+ }+ if len(credentials) == 0 {+ logReason = "issuer_not_allowed"+ return nil, &common.FederatedCredentialInvalidGrantError{}+ }++ verifiedToken, verifiedClaims, err := s.verifySubjectTokenInternal(ctx, issuer, req.SubjectToken)+ if err != nil {+ logReason = "token_verification_failed"+ return nil, fmt.Errorf("%w: %w", &common.FederatedCredentialInvalidGrantError{}, err)+ }+ if subject == "" {+ subject = stringClaimByPathInternal(verifiedClaims, defaultFederatedSubjectClaim)+ }+ if len(audiences) == 0 {+ audiences = append([]string{}, verifiedToken.Audience...)+ }++ credential := selectMatchingCredentialInternal(credentials, verifiedToken.Audience, verifiedClaims)+ if credential == nil {+ logReason = "no_matching_credential"+ return nil, &common.FederatedCredentialInvalidGrantError{}+ }+ matchedCredential = credential+ if err := s.recordTokenReplayGuardInternal(ctx, issuer, req.SubjectToken, verifiedClaims, verifiedToken.Expiry); err != nil {+ logReason = "token_replay_rejected"+ return nil, err+ }++ user, err := s.userService.GetUserByID(ctx, credential.IdentityUserID)+ if err != nil {+ logReason = "identity_user_missing"+ return nil, fmt.Errorf("%w: %w", &common.FederatedCredentialInvalidGrantError{}, err)+ }+ matchedUser = user++ tokenPair, err := s.authService.IssueFederatedToken(ctx, user, credential.ID, credential.TokenTTLSeconds)+ if err != nil {+ logReason = "token_issue_failed"+ return nil, err+ }++ s.markCredentialUsedAsyncInternal(ctx, credential.ID)+ logResult = "success"+ logReason = "matched"++ return &federatedtypes.FederatedTokenResponse{+ AccessToken: tokenPair.AccessToken,+ TokenType: "Bearer",+ ExpiresIn: max(int(time.Until(tokenPair.ExpiresAt).Seconds()), 0),+ IssuedTokenType: federatedtypes.IssuedTokenTypeAccessToken,+ }, nil+}++func (s *FederatedCredentialService) Create(ctx context.Context, callerUserID string, req federatedtypes.CreateFederatedCredential) (*federatedtypes.FederatedCredential, error) {+ normalized, err := normalizeCreateFederatedCredentialInternal(req)+ if err != nil {+ return nil, err+ }+ if err := s.validateRoleGrantAgainstUserInternal(ctx, callerUserID, normalized.RoleID, normalized.EnvironmentID); err != nil {+ return nil, err+ }++ var created models.FederatedCredential+ err = dbutil.WithTx(ctx, s.db.DB, func(tx *gorm.DB) error {+ serviceUser := models.User{+ Username: "svc_federated_" + strings.ReplaceAll(uuid.NewString(), "-", ""),+ DisplayName: pkgutils.StringPtrFromTrimmed("Federated: " + normalized.Name),+ IsServiceAccount: true,+ }+ if err := tx.Create(&serviceUser).Error; err != nil {+ return fmt.Errorf("failed to create federated service user: %w", err)+ }++ created = models.FederatedCredential{+ Name: normalized.Name,+ Description: normalized.Description,+ Enabled: normalized.Enabled,+ IssuerURL: normalized.IssuerURL,+ Audiences: models.StringSlice(normalized.Audiences),+ SubjectClaim: normalized.SubjectClaim,+ SubjectMatch: normalized.SubjectMatch,+ MatchType: normalized.MatchType,+ RoleID: normalized.RoleID,+ EnvironmentID: normalized.EnvironmentID,+ IdentityUserID: serviceUser.ID,+ TokenTTLSeconds: normalized.TokenTTLSeconds,+ ExpiresAt: normalized.ExpiresAt,+ }+ if err := tx.Create(&created).Error; err != nil {+ return fmt.Errorf("failed to create federated credential: %w", err)+ }++ assignment := models.UserRoleAssignment{+ UserID: serviceUser.ID,+ RoleID: normalized.RoleID,+ EnvironmentID: normalized.EnvironmentID,+ Source: models.RoleAssignmentSourceManual,+ }+ if err := tx.Create(&assignment).Error; err != nil {+ return fmt.Errorf("failed to create federated role assignment: %w", err)+ }++ return nil+ })+ if err != nil {+ return nil, err+ }+ if s.roleService != nil {+ s.roleService.InvalidateUser(created.IdentityUserID)+ }++ reloaded, err := s.Get(ctx, created.ID)+ if err != nil {+ return nil, err+ }+ return reloaded, nil+}++func (s *FederatedCredentialService) List(ctx context.Context, params pagination.QueryParams) ([]federatedtypes.FederatedCredential, pagination.Response, error) {+ var credentials []models.FederatedCredential+ query := s.db.WithContext(ctx).+ Model(&models.FederatedCredential{}).+ Preload("IdentityUser").+ Preload("Role").+ Preload("Environment")++ if term := strings.TrimSpace(params.Search); term != "" {+ pattern := "%" + term + "%"+ query = query.Where("name LIKE ? OR COALESCE(description, '') LIKE ? OR issuer_url LIKE ? OR subject_match LIKE ?", pattern, pattern, pattern, pattern)+ }++ resp, err := pagination.PaginateAndSortDB(params, query, &credentials)+ if err != nil {+ return nil, pagination.Response{}, fmt.Errorf("failed to paginate federated credentials: %w", err)+ }++ result := make([]federatedtypes.FederatedCredential, len(credentials))+ for i := range credentials {+ result[i] = toFederatedCredentialDTOInternal(&credentials[i])+ }+ return result, resp, nil+}++func (s *FederatedCredentialService) Get(ctx context.Context, id string) (*federatedtypes.FederatedCredential, error) {+ var credential models.FederatedCredential+ if err := s.db.WithContext(ctx).+ Preload("IdentityUser").+ Preload("Role").+ Preload("Environment").+ Where("id = ?", id).+ First(&credential).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, &common.FederatedCredentialNotFoundError{}+ }+ return nil, fmt.Errorf("failed to get federated credential: %w", err)+ }+ dto := toFederatedCredentialDTOInternal(&credential)+ return &dto, nil+}++func (s *FederatedCredentialService) Update(ctx context.Context, callerUserID string, id string, req federatedtypes.UpdateFederatedCredential) (*federatedtypes.FederatedCredential, error) {+ var credential models.FederatedCredential+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&credential).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, &common.FederatedCredentialNotFoundError{}+ }+ return nil, fmt.Errorf("failed to load federated credential: %w", err)+ }++ updated, roleChanged, err := applyFederatedCredentialUpdateInternal(credential, req)+ if err != nil {+ return nil, err+ }+ revokeActiveSessions := credential.Enabled && !updated.Enabled+ if roleChanged {+ if err := s.validateRoleGrantAgainstUserInternal(ctx, callerUserID, updated.RoleID, updated.EnvironmentID); err != nil {+ return nil, err+ }+ }++ err = dbutil.WithTx(ctx, s.db.DB, func(tx *gorm.DB) error {+ if err := tx.Save(&updated).Error; err != nil {+ return fmt.Errorf("failed to update federated credential: %w", err)+ }+ if revokeActiveSessions {+ if err := revokeFederatedCredentialSessionsInternal(tx, updated.ID); err != nil {+ return err+ }+ }+ if roleChanged {+ if err := tx.Where("user_id = ? AND source = ?", updated.IdentityUserID, models.RoleAssignmentSourceManual).+ Delete(&models.UserRoleAssignment{}).Error; err != nil {+ return fmt.Errorf("failed to clear federated role assignment: %w", err)+ }+ assignment := models.UserRoleAssignment{+ UserID: updated.IdentityUserID,+ RoleID: updated.RoleID,+ EnvironmentID: updated.EnvironmentID,+ Source: models.RoleAssignmentSourceManual,+ }+ if err := tx.Create(&assignment).Error; err != nil {+ return fmt.Errorf("failed to update federated role assignment: %w", err)+ }+ }+ return nil+ })+ if err != nil {+ return nil, err+ }+ if roleChanged && s.roleService != nil {+ s.roleService.InvalidateUser(updated.IdentityUserID)+ }++ return s.Get(ctx, id)+}++func (s *FederatedCredentialService) Delete(ctx context.Context, id string) error {+ var credential models.FederatedCredential+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&credential).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return &common.FederatedCredentialNotFoundError{}+ }+ return fmt.Errorf("failed to load federated credential: %w", err)+ }++ err := dbutil.WithTx(ctx, s.db.DB, func(tx *gorm.DB) error {+ if err := tx.Delete(&models.FederatedCredential{}, "id = ?", credential.ID).Error; err != nil {+ return fmt.Errorf("failed to delete federated credential: %w", err)+ }+ if err := tx.Delete(&models.User{}, "id = ?", credential.IdentityUserID).Error; err != nil {+ return fmt.Errorf("failed to delete federated service user: %w", err)+ }+ return nil+ })+ if err != nil {+ return err+ }+ if s.roleService != nil {+ s.roleService.InvalidateUser(credential.IdentityUserID)+ }+ return nil+}++func validateTokenExchangeRequestInternal(req federatedtypes.TokenExchangeRequest) error {+ if req.GrantType != federatedtypes.TokenExchangeGrantType {+ return &common.FederatedCredentialInvalidRequestError{}+ }+ if strings.TrimSpace(req.SubjectToken) == "" {+ return &common.FederatedCredentialInvalidRequestError{}+ }+ switch req.SubjectTokenType {+ case federatedtypes.SubjectTokenTypeJWT, federatedtypes.SubjectTokenTypeIDToken:+ default:+ return &common.FederatedCredentialInvalidRequestError{}+ }+ if req.RequestedTokenType != "" && req.RequestedTokenType != federatedtypes.RequestedTokenTypeAccessJWT {+ return &common.FederatedCredentialInvalidRequestError{}+ }+ return nil+}++func (s *FederatedCredentialService) listEnabledCredentialsForIssuerInternal(ctx context.Context, issuer string) ([]models.FederatedCredential, error) {+ var credentials []models.FederatedCredential+ if err := s.db.WithContext(ctx).+ Where("issuer_url = ? AND enabled = ?", issuer, true).+ Order("created_at ASC").+ Order("id ASC").+ Find(&credentials).Error; err != nil {+ return nil, fmt.Errorf("failed to list federated credentials for issuer: %w", err)+ }++ now := time.Now()+ active := credentials[:0]+ for _, credential := range credentials {+ if credential.ExpiresAt != nil && now.After(*credential.ExpiresAt) {+ continue+ }+ active = append(active, credential)+ }+ return active, nil+}++func (s *FederatedCredentialService) verifySubjectTokenInternal(ctx context.Context, issuer string, rawToken string) (*oidc.IDToken, map[string]any, error) {+ provider, err := s.providerForIssuerInternal(ctx, issuer)+ if err != nil {+ return nil, nil, err+ }++ providerCtx := oidc.ClientContext(ctx, s.httpClient)+ verifier := provider.Verifier(&oidc.Config{SkipClientIDCheck: true})+ idToken, err := verifier.Verify(providerCtx, rawToken)+ if err != nil {+ return nil, nil, err+ }++ claims := map[string]any{}+ if err := idToken.Claims(&claims); err != nil {+ return nil, nil, err+ }+ return idToken, claims, nil+}++func (s *FederatedCredentialService) recordTokenReplayGuardInternal(ctx context.Context, issuer string, rawToken string, claims map[string]any, expiresAt time.Time) error {+ if expiresAt.IsZero() || time.Now().After(expiresAt) {+ return &common.FederatedCredentialInvalidGrantError{}+ }++ now := time.Now()+ if err := s.db.WithContext(ctx).+ Where("expires_at < ?", now).+ Delete(&models.FederatedTokenReplay{}).Error; err != nil {+ return fmt.Errorf("failed to prune federated token replay records: %w", err)+ }++ replay := models.FederatedTokenReplay{+ TokenHash: federatedTokenReplayHashInternal(issuer, rawToken, claims),+ IssuerURL: issuer,+ ExpiresAt: expiresAt,+ }+ if err := s.db.WithContext(ctx).Create(&replay).Error; err != nil {+ if isUniqueConstraintErrorInternal(err) {+ return &common.FederatedCredentialInvalidGrantError{}+ }+ return fmt.Errorf("failed to record federated token replay guard: %w", err)+ }+ return nil+}++func federatedTokenReplayHashInternal(issuer string, rawToken string, claims map[string]any) string {+ tokenID := strings.TrimSpace(stringClaimByPathInternal(claims, "jti"))+ tokenKind := "jti"+ if tokenID == "" {+ tokenID = rawToken+ tokenKind = "token"+ }++ sum := sha256.Sum256([]byte(issuer + "\x00" + tokenKind + "\x00" + tokenID))+ return hex.EncodeToString(sum[:])+}++func isUniqueConstraintErrorInternal(err error) bool {+ if err == nil {+ return false+ }+ msg := strings.ToLower(err.Error())+ return strings.Contains(msg, "unique") || strings.Contains(msg, "duplicate key")+}++func (s *FederatedCredentialService) providerForIssuerInternal(ctx context.Context, issuer string) (*oidc.Provider, error) {+ s.providerMu.RLock()+ if provider := s.providers[issuer]; provider != nil {+ s.providerMu.RUnlock()+ return provider, nil+ }+ s.providerMu.RUnlock()++ v, err, _ := s.providerGroup.Do(issuer, func() (any, error) {+ providerCtx := oidc.ClientContext(context.WithoutCancel(ctx), s.httpClient)+ provider, err := oidc.NewProvider(providerCtx, issuer)+ if err != nil {+ return nil, fmt.Errorf("failed to discover federated issuer: %w", err)+ }++ s.providerMu.Lock()+ s.providers[issuer] = provider+ s.providerMu.Unlock()+ return provider, nil+ })+ if err != nil {+ return nil, err+ }++ provider, ok := v.(*oidc.Provider)+ if !ok || provider == nil {+ return nil, fmt.Errorf("federated issuer discovery returned invalid provider")+ }+ return provider, nil+}++func selectMatchingCredentialInternal(credentials []models.FederatedCredential, tokenAudiences []string, claims map[string]any) *models.FederatedCredential {+ for i := range credentials {+ credential := &credentials[i]+ if !audienceMatchesInternal(tokenAudiences, []string(credential.Audiences)) {+ continue+ }+ subjectClaim := strings.TrimSpace(credential.SubjectClaim)+ if subjectClaim == "" {+ subjectClaim = defaultFederatedSubjectClaim+ }+ subject := stringClaimByPathInternal(claims, subjectClaim)+ if !subjectMatchesInternal(credential.MatchType, credential.SubjectMatch, subject) {+ continue+ }+ return credential+ }+ return nil+}++func audienceMatchesInternal(tokenAudiences, credentialAudiences []string) bool {+ allowed := make(map[string]struct{}, len(credentialAudiences))+ for _, audience := range credentialAudiences {+ audience = strings.TrimSpace(audience)+ if audience != "" {+ allowed[audience] = struct{}{}+ }+ }+ for _, audience := range tokenAudiences {+ if _, ok := allowed[audience]; ok {+ return true+ }+ }+ return false+}++func subjectMatchesInternal(matchType, pattern, subject string) bool {+ if subject == "" {+ return false+ }+ switch normalizeMatchTypeInternal(matchType) {+ case federatedtypes.MatchTypeGlob:+ return anchoredGlobMatchesInternal(pattern, subject)+ default:+ return subject == pattern+ }+}++func anchoredGlobMatchesInternal(pattern, value string) bool {+ var b strings.Builder+ b.WriteString("^")+ for _, r := range pattern {+ switch r {+ case '*':+ b.WriteString(".*")+ case '?':+ b.WriteByte('.')+ default:+ b.WriteString(regexp.QuoteMeta(string(r)))+ }+ }+ b.WriteString("$")+ matched, err := regexp.MatchString(b.String(), value)+ return err == nil && matched+}++func unverifiedTokenExchangeMetadataInternal(rawToken string) (string, string, []string) {+ claims := jwtclaims.ParseJWTClaims(rawToken)+ if claims == nil {+ return "", "", nil+ }+ return stringClaimByPathInternal(claims, "iss"), stringClaimByPathInternal(claims, "sub"), stringSliceClaimInternal(claims, "aud")+}++func stringClaimByPathInternal(claims map[string]any, path string) string {+ value, ok := jwtclaims.GetByPath(claims, path)+ if !ok {+ return ""+ }+ return pkgutils.ToString(value)+}++func stringSliceClaimInternal(claims map[string]any, path string) []string {+ value, ok := jwtclaims.GetByPath(claims, path)+ if !ok || value == nil {+ return nil+ }+ switch typed := value.(type) {+ case string:+ if strings.TrimSpace(typed) == "" {+ return nil+ }+ return []string{strings.TrimSpace(typed)}+ case []string:+ return pkgutils.UniqueNonEmptyStrings(typed)+ case []any:+ out := make([]string, 0, len(typed))+ for _, item := range typed {+ if value := pkgutils.ToString(item); value != "" {+ out = append(out, value)+ }+ }+ return pkgutils.UniqueNonEmptyStrings(out)+ default:+ return nil+ }+}++func normalizeCreateFederatedCredentialInternal(req federatedtypes.CreateFederatedCredential) (federatedtypes.CreateFederatedCredential, error) {+ req.Name = strings.TrimSpace(req.Name)+ req.IssuerURL = strings.TrimRight(strings.TrimSpace(req.IssuerURL), "/")+ req.SubjectClaim = strings.TrimSpace(req.SubjectClaim)+ req.SubjectMatch = strings.TrimSpace(req.SubjectMatch)+ req.MatchType = normalizeMatchTypeInternal(req.MatchType)+ req.Audiences = pkgutils.UniqueNonEmptyStrings(req.Audiences)+ req.EnvironmentID = pkgutils.StringPtrFromTrimmed(pkgutils.DerefString(req.EnvironmentID))+ req.TokenTTLSeconds = clampFederatedTokenTTLSecondsInternal(req.TokenTTLSeconds)++ if req.SubjectClaim == "" {+ req.SubjectClaim = defaultFederatedSubjectClaim+ }+ if req.Name == "" || req.SubjectMatch == "" || req.RoleID == "" || len(req.Audiences) == 0 {+ return req, &common.FederatedCredentialInvalidError{}+ }+ if err := validateIssuerURLInternal(req.IssuerURL); err != nil {+ return req, err+ }+ if err := validateSubjectMatchInternal(req.MatchType, req.SubjectMatch); err != nil {+ return req, err+ }+ return req, nil+}++func applyFederatedCredentialUpdateInternal(existing models.FederatedCredential, req federatedtypes.UpdateFederatedCredential) (models.FederatedCredential, bool, error) {+ roleChanged := false+ if req.Name != nil {+ name := strings.TrimSpace(*req.Name)+ if name == "" {+ return existing, false, &common.FederatedCredentialInvalidError{}+ }+ existing.Name = name+ }+ if req.Description != nil {+ existing.Description = req.Description+ }+ if req.Enabled != nil {+ existing.Enabled = *req.Enabled+ }+ if req.IssuerURL != nil {+ issuerURL := strings.TrimRight(strings.TrimSpace(*req.IssuerURL), "/")+ if err := validateIssuerURLInternal(issuerURL); err != nil {+ return existing, false, err+ }+ existing.IssuerURL = issuerURL+ }+ if req.Audiences != nil {+ audiences := pkgutils.UniqueNonEmptyStrings(req.Audiences)+ if len(audiences) == 0 {+ return existing, false, &common.FederatedCredentialInvalidError{}+ }+ existing.Audiences = models.StringSlice(audiences)+ }+ if req.SubjectClaim != nil {+ subjectClaim := strings.TrimSpace(*req.SubjectClaim)+ if subjectClaim == "" {+ subjectClaim = defaultFederatedSubjectClaim+ }+ existing.SubjectClaim = subjectClaim+ }+ if req.SubjectMatch != nil {+ subjectMatch := strings.TrimSpace(*req.SubjectMatch)+ if subjectMatch == "" {+ return existing, false, &common.FederatedCredentialInvalidError{}+ }+ existing.SubjectMatch = subjectMatch+ }+ if req.MatchType != nil {+ existing.MatchType = normalizeMatchTypeInternal(*req.MatchType)+ }+ if err := validateSubjectMatchInternal(existing.MatchType, existing.SubjectMatch); err != nil {+ return existing, false, err+ }+ roleChanged, err := applyFederatedRoleScopeUpdateInternal(&existing, req.RoleID, req.EnvironmentID)+ if err != nil {+ return existing, false, err+ }+ if req.TokenTTLSeconds != nil {+ existing.TokenTTLSeconds = clampFederatedTokenTTLSecondsInternal(*req.TokenTTLSeconds)+ }+ if req.ExpiresAt != nil {+ existing.ExpiresAt = req.ExpiresAt+ }+ return existing, roleChanged, nil+}++func applyFederatedRoleScopeUpdateInternal(existing *models.FederatedCredential, roleID *string, environmentID *string) (bool, error) {+ if existing == nil {+ return false, &common.FederatedCredentialInvalidError{}+ }++ roleChanged := false+ if roleID != nil {+ normalizedRoleID := strings.TrimSpace(*roleID)+ if normalizedRoleID == "" {+ return false, &common.FederatedCredentialInvalidError{}+ }+ roleChanged = roleChanged || normalizedRoleID != existing.RoleID+ existing.RoleID = normalizedRoleID+ }+ if environmentID != nil {+ normalized := pkgutils.StringPtrFromTrimmed(*environmentID)+ roleChanged = roleChanged || pkgutils.DerefString(existing.EnvironmentID) != pkgutils.DerefString(normalized)+ existing.EnvironmentID = normalized+ }+ return roleChanged, nil+}++func normalizeMatchTypeInternal(matchType string) string {+ switch strings.ToLower(strings.TrimSpace(matchType)) {+ case federatedtypes.MatchTypeGlob:+ return federatedtypes.MatchTypeGlob+ default:+ return federatedtypes.MatchTypeExact+ }+}++func validateIssuerURLInternal(rawURL string) error {+ parsed, err := url.Parse(rawURL)+ if err != nil || parsed == nil || parsed.Host == "" || parsed.Scheme != "https" {+ return fmt.Errorf("%w: issuerUrl must be an HTTPS URL", &common.FederatedCredentialInvalidError{})+ }+ return nil+}++func validateSubjectMatchInternal(matchType, subjectMatch string) error {+ if strings.TrimSpace(subjectMatch) == "" {+ return &common.FederatedCredentialInvalidError{}+ }+ if normalizeMatchTypeInternal(matchType) == federatedtypes.MatchTypeGlob && strings.TrimSpace(subjectMatch) == "*" {+ return &common.FederatedCredentialInvalidError{}+ }+ return nil+}++func (s *FederatedCredentialService) validateRoleGrantAgainstUserInternal(ctx context.Context, userID, roleID string, environmentID *string) error {+ if s.roleService == nil || strings.TrimSpace(userID) == "" {+ return nil+ }++ user, err := s.userService.GetUserByID(ctx, userID)+ if err != nil {+ return fmt.Errorf("load user for federated role validation: %w", err)+ }++ ps, err := s.roleService.ResolvePermissions(ctx, user)+ if err != nil {+ return fmt.Errorf("resolve user permissions: %w", err)+ }++ if err := s.roleService.ValidateRoleAssignmentAgainstCaller(ctx, ps, roleID, environmentID); err != nil {+ if common.IsRolePermissionEscalationError(err) {+ return fmt.Errorf("%w: %w", &common.FederatedCredentialPermissionEscalationError{}, err)+ }+ return fmt.Errorf("%w: %w", &common.FederatedCredentialInvalidError{}, err)+ }+ return nil+}++func revokeFederatedCredentialSessionsInternal(tx *gorm.DB, credentialID string) error {+ if tx == nil || strings.TrimSpace(credentialID) == "" {+ return nil+ }++ now := time.Now()+ if err := tx.Model(&models.UserSession{}).+ Where("federated_credential_id = ? AND revoked_at IS NULL", credentialID).+ Updates(map[string]any{"revoked_at": now, "updated_at": now}).Error; err != nil {+ return fmt.Errorf("failed to revoke federated credential sessions: %w", err)+ }+ return nil+}++func toFederatedCredentialDTOInternal(credential *models.FederatedCredential) federatedtypes.FederatedCredential {+ if credential == nil {+ return federatedtypes.FederatedCredential{}+ }+ dto := federatedtypes.FederatedCredential{+ ID: credential.ID,+ Name: credential.Name,+ Description: credential.Description,+ Enabled: credential.Enabled,+ IssuerURL: credential.IssuerURL,+ Audiences: []string(credential.Audiences),+ SubjectClaim: credential.SubjectClaim,+ SubjectMatch: credential.SubjectMatch,+ MatchType: credential.MatchType,+ RoleID: credential.RoleID,+ EnvironmentID: credential.EnvironmentID,+ IdentityUserID: credential.IdentityUserID,+ TokenTTLSeconds: credential.TokenTTLSeconds,+ LastUsedAt: credential.LastUsedAt,+ ExpiresAt: credential.ExpiresAt,+ CreatedAt: credential.CreatedAt,+ UpdatedAt: credential.UpdatedAt,+ }+ if credential.IdentityUser != nil {+ dto.ServiceUsername = credential.IdentityUser.Username+ }+ if credential.Role != nil {+ dto.RoleName = credential.Role.Name+ }+ if credential.Environment != nil {+ dto.EnvironmentName = credential.Environment.Name+ }+ return dto+}++func (s *FederatedCredentialService) markCredentialUsedAsyncInternal(ctx context.Context, credentialID string) {+ go func() {+ bgCtx := context.WithoutCancel(ctx)+ now := time.Now()+ cutoff := now.Add(-federatedCredentialLastUsedWriteWindow)+ if err := s.db.WithContext(bgCtx).+ Model(&models.FederatedCredential{}).+ Where("id = ? AND (last_used_at IS NULL OR last_used_at < ?)", credentialID, cutoff).+ Update("last_used_at", now).Error; err != nil {+ slog.WarnContext(bgCtx, "failed to update federated credential last_used_at", "credential_id", credentialID, "error", err)+ }+ }()+}++func (s *FederatedCredentialService) logExchangeInternal(ctx context.Context, result, reason, issuer, subject string, audiences []string, credential *models.FederatedCredential, user *models.User) {+ credentialID := ""+ credentialName := ""+ if credential != nil {+ credentialID = credential.ID+ credentialName = credential.Name+ }+ slog.InfoContext(ctx, "Federated credential token exchange",+ "result", result,+ "reason", reason,+ "issuer", issuer,+ "subject", subject,+ "audiences", audiences,+ "credential_id", credentialID,+ )++ if s.eventService == nil {+ return+ }++ metadata := models.JSON{+ "action": "federated_token_exchange",+ "result": result,+ "reason": reason,+ "issuer": issuer,+ "subject": subject,+ "audiences": audiences,+ "credentialId": credentialID,+ }++ userID := ""+ username := ""+ if user != nil {+ userID = user.ID+ username = user.Username+ }+ severity := models.EventSeverityInfo+ title := "Federated credential token exchange"+ if result != "success" {+ severity = models.EventSeverityWarning+ title = "Federated credential token exchange rejected"+ }++ go func() {+ bgCtx := context.WithoutCancel(ctx)+ _, err := s.eventService.CreateEvent(bgCtx, CreateEventRequest{+ Type: models.EventTypeFederatedExchange,+ Severity: severity,+ Title: title,+ Description: "Workload identity federation token exchange",+ ResourceType: pkgutils.StringPtrFromTrimmed("federated_credential"),+ ResourceID: pkgutils.StringPtrFromTrimmed(credentialID),+ ResourceName: pkgutils.StringPtrFromTrimmed(credentialName),+ UserID: pkgutils.StringPtrFromTrimmed(userID),+ Username: pkgutils.StringPtrFromTrimmed(username),+ Metadata: metadata,+ })+ if err != nil {+ slog.WarnContext(bgCtx, "failed to audit federated credential token exchange", "error", err)+ }+ }()+}diff --git a/backend/internal/services/federated_credential_service_test.go b/backend/internal/services/federated_credential_service_test.gonew file mode 100644index 000000000..745d982bd--- /dev/null+++ b/backend/internal/services/federated_credential_service_test.go@@ -0,0 +1,363 @@+package services++import (+ "context"+ "crypto/rand"+ "crypto/rsa"+ "encoding/base64"+ "encoding/json"+ "fmt"+ "math/big"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"++ glsqlite "github.com/glebarez/sqlite"+ "github.com/golang-jwt/jwt/v5"+ "github.com/stretchr/testify/require"+ "gorm.io/gorm"++ "github.com/getarcaneapp/arcane/backend/internal/common"+ "github.com/getarcaneapp/arcane/backend/internal/config"+ "github.com/getarcaneapp/arcane/backend/internal/database"+ "github.com/getarcaneapp/arcane/backend/internal/models"+ "github.com/getarcaneapp/arcane/backend/pkg/authz"+ federatedtypes "github.com/getarcaneapp/arcane/types/federated"+)++type federatedTestIssuerInternal struct {+ IssuerURL string+ private *rsa.PrivateKey+ keyID string+ server *httptest.Server+}++func newFederatedTestIssuerInternal(t *testing.T) *federatedTestIssuerInternal {+ t.Helper()++ privateKey, err := rsa.GenerateKey(rand.Reader, 2048)+ require.NoError(t, err)++ issuer := &federatedTestIssuerInternal{+ private: privateKey,+ keyID: "federated-test-key",+ }++ mux := http.NewServeMux()+ mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, _ *http.Request) {+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{+ "issuer": issuer.IssuerURL,+ "jwks_uri": issuer.IssuerURL + "/jwks",+ "authorization_endpoint": issuer.IssuerURL + "/authorize",+ "token_endpoint": issuer.IssuerURL + "/token",+ "subject_types_supported": []string{"public"},+ "id_token_signing_alg_values_supported": []string{"RS256"},+ }))+ })+ mux.HandleFunc("/jwks", func(w http.ResponseWriter, _ *http.Request) {+ pub := privateKey.PublicKey+ require.NoError(t, json.NewEncoder(w).Encode(map[string]any{+ "keys": []map[string]any{+ {+ "kty": "RSA",+ "use": "sig",+ "kid": issuer.keyID,+ "alg": "RS256",+ "n": base64.RawURLEncoding.EncodeToString(pub.N.Bytes()),+ "e": base64.RawURLEncoding.EncodeToString(big.NewInt(int64(pub.E)).Bytes()),+ },+ },+ }))+ })++ issuer.server = httptest.NewServer(mux)+ issuer.IssuerURL = issuer.server.URL+ t.Cleanup(issuer.server.Close)++ return issuer+}++func (i *federatedTestIssuerInternal) tokenInternal(t *testing.T, subject string, audience []string) string {+ t.Helper()++ now := time.Now()+ claims := jwt.MapClaims{+ "iss": i.IssuerURL,+ "sub": subject,+ "aud": audience,+ "iat": now.Unix(),+ "nbf": now.Add(-time.Minute).Unix(),+ "exp": now.Add(5 * time.Minute).Unix(),+ }++ token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)+ token.Header["kid"] = i.keyID+ signed, err := token.SignedString(i.private)+ require.NoError(t, err)+ return signed+}++func setupFederatedCredentialServiceTestDBInternal(t *testing.T) *database.DB {+ t.Helper()++ dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared", strings.NewReplacer("/", "_", " ", "_").Replace(t.Name()))+ db, err := gorm.Open(glsqlite.Open(dsn), &gorm.Config{})+ require.NoError(t, err)+ require.NoError(t, db.AutoMigrate(+ &models.SettingVariable{},+ &models.User{},+ &models.UserSession{},+ &models.Role{},+ &models.UserRoleAssignment{},+ &models.FederatedCredential{},+ &models.FederatedTokenReplay{},+ &models.Event{},+ ))++ sqlDB, err := db.DB()+ require.NoError(t, err)+ sqlDB.SetMaxOpenConns(1)+ sqlDB.SetMaxIdleConns(1)++ return &database.DB{DB: db}+}++func setupFederatedCredentialServiceInternal(t *testing.T, issuer *federatedTestIssuerInternal) (*FederatedCredentialService, *AuthService, *database.DB) {+ t.Helper()++ ctx := context.Background()+ db := setupFederatedCredentialServiceTestDBInternal(t)+ roleSvc := NewRoleService(db)+ userSvc := NewUserService(db).WithRoleService(roleSvc)+ sessionSvc := NewSessionService(db)+ settingsSvc, err := NewSettingsService(ctx, db)+ require.NoError(t, err)+ eventSvc := NewEventService(db, &config.Config{}, nil)+ authSvc := NewAuthService(userSvc, settingsSvc, eventSvc, sessionSvc, roleSvc, "test-federated-secret", &config.Config{+ JWTRefreshExpiry: 24 * time.Hour,+ })++ service := NewFederatedCredentialService(db, authSvc, userSvc, settingsSvc, eventSvc, issuer.server.Client()).WithRoleService(roleSvc)++ role := models.Role{+ BaseModel: models.BaseModel{ID: "role-federated-viewer"},+ Name: "Federated Viewer",+ Permissions: models.StringSlice{authz.PermProjectsList},+ }+ require.NoError(t, db.WithContext(ctx).Create(&role).Error)++ serviceUser := models.User{+ BaseModel: models.BaseModel{ID: "user-federated-service"},+ Username: "svc-federated-demo",+ IsServiceAccount: true,+ }+ require.NoError(t, db.WithContext(ctx).Create(&serviceUser).Error)+ require.NoError(t, db.WithContext(ctx).Create(&models.UserRoleAssignment{+ UserID: serviceUser.ID,+ RoleID: role.ID,+ }).Error)++ credential := models.FederatedCredential{+ BaseModel: models.BaseModel{ID: "cred-github-actions"},+ Name: "GitHub Actions",+ Enabled: true,+ IssuerURL: issuer.IssuerURL,+ Audiences: models.StringSlice{"arcane-ci"},+ SubjectClaim: "sub",+ SubjectMatch: "repo:getarcaneapp/arcane:*",+ MatchType: federatedtypes.MatchTypeGlob,+ RoleID: role.ID,+ IdentityUserID: serviceUser.ID,+ TokenTTLSeconds: 900,+ }+ require.NoError(t, db.WithContext(ctx).Create(&credential).Error)++ return service, authSvc, db+}++func TestFederatedCredentialServiceExchangeToken(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, authSvc, db := setupFederatedCredentialServiceInternal(t, issuer)+ ctx := context.Background()++ tests := []struct {+ name string+ token string+ wantError func(error) bool+ }{+ {+ name: "issues an Arcane bearer token for a matching issuer audience and subject",+ token: issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),+ },+ {+ name: "rejects audience mismatch",+ token: issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"other-audience"}),+ wantError: func(err error) bool {+ return common.IsErrorFederatedCredentialInvalidGrant(err)+ },+ },+ {+ name: "rejects subject mismatch",+ token: issuer.tokenInternal(t, "repo:other/repo:ref:refs/heads/main", []string{"arcane-ci"}),+ wantError: func(err error) bool {+ return common.IsErrorFederatedCredentialInvalidGrant(err)+ },+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ resp, err := service.ExchangeToken(ctx, federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: tt.token,+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ })+ if tt.wantError != nil {+ require.Error(t, err)+ require.True(t, tt.wantError(err), "unexpected error: %v", err)+ require.Nil(t, resp)+ return+ }++ require.NoError(t, err)+ require.NotNil(t, resp)+ require.Equal(t, "Bearer", resp.TokenType)+ require.Equal(t, federatedtypes.IssuedTokenTypeAccessToken, resp.IssuedTokenType)+ require.Positive(t, resp.ExpiresIn)+ require.NotEmpty(t, resp.AccessToken)++ user, sessionID, err := authSvc.VerifyToken(ctx, resp.AccessToken)+ require.NoError(t, err)+ require.Equal(t, "user-federated-service", user.ID)++ var session models.UserSession+ require.NoError(t, db.WithContext(ctx).Where("id = ?", sessionID).First(&session).Error)+ require.Equal(t, models.UserSessionSourceFederated, session.Source)+ require.NotNil(t, session.FederatedCredentialID)+ require.Equal(t, "cred-github-actions", *session.FederatedCredentialID)+ })+ }+}++func TestFederatedCredentialServiceExchangeTokenRejectsIssuerWithoutCredentialInternal(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ otherIssuer := newFederatedTestIssuerInternal(t)+ service, _, _ := setupFederatedCredentialServiceInternal(t, issuer)++ resp, err := service.ExchangeToken(context.Background(), federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: otherIssuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ })++ require.Error(t, err)+ require.True(t, common.IsErrorFederatedCredentialInvalidGrant(err), "unexpected error: %v", err)+ require.Nil(t, resp)+}++func TestFederatedCredentialServiceExchangeTokenDoesNotRequireGlobalFeatureFlagInternal(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, _, _ := setupFederatedCredentialServiceInternal(t, issuer)+ service.settingsService = nil++ resp, err := service.ExchangeToken(context.Background(), federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ })++ require.NoError(t, err)+ require.NotNil(t, resp)+ require.NotEmpty(t, resp.AccessToken)+}++func TestFederatedCredentialServiceExchangeTokenRejectsExpiredCredentialInternal(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, _, db := setupFederatedCredentialServiceInternal(t, issuer)+ expiredAt := time.Now().Add(-time.Minute)+ require.NoError(t, db.WithContext(context.Background()).+ Model(&models.FederatedCredential{}).+ Where("id = ?", "cred-github-actions").+ Update("expires_at", expiredAt).Error)++ resp, err := service.ExchangeToken(context.Background(), federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ })++ require.Error(t, err)+ require.True(t, common.IsErrorFederatedCredentialInvalidGrant(err), "unexpected error: %v", err)+ require.Nil(t, resp)+}++func TestFederatedCredentialServiceUpdateDisableRevokesIssuedSessionsInternal(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, authSvc, _ := setupFederatedCredentialServiceInternal(t, issuer)+ ctx := context.Background()++ resp, err := service.ExchangeToken(ctx, federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"}),+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ })+ require.NoError(t, err)+ require.NotNil(t, resp)++ disabled := false+ _, err = service.Update(ctx, "admin-user", "cred-github-actions", federatedtypes.UpdateFederatedCredential{+ Enabled: &disabled,+ })+ require.NoError(t, err)++ _, _, err = authSvc.VerifyToken(ctx, resp.AccessToken)+ require.Error(t, err)+ require.True(t, common.IsSessionRevokedError(err), "unexpected error: %v", err)+}++func TestFederatedCredentialServiceRejectsReplayedSubjectTokenInternal(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, _, _ := setupFederatedCredentialServiceInternal(t, issuer)+ ctx := context.Background()+ subjectToken := issuer.tokenInternal(t, "repo:getarcaneapp/arcane:ref:refs/heads/main", []string{"arcane-ci"})+ req := federatedtypes.TokenExchangeRequest{+ GrantType: federatedtypes.TokenExchangeGrantType,+ SubjectToken: subjectToken,+ SubjectTokenType: federatedtypes.SubjectTokenTypeJWT,+ Audience: "https://arcane.example.com",+ }++ first, err := service.ExchangeToken(ctx, req)+ require.NoError(t, err)+ require.NotNil(t, first)++ second, err := service.ExchangeToken(ctx, req)+ require.Error(t, err)+ require.True(t, common.IsErrorFederatedCredentialInvalidGrant(err), "unexpected error: %v", err)+ require.Nil(t, second)+}++func TestFederatedCredentialServiceCreateRejectsBareWildcardGlob(t *testing.T) {+ issuer := newFederatedTestIssuerInternal(t)+ service, _, _ := setupFederatedCredentialServiceInternal(t, issuer)++ _, err := service.Create(context.Background(), "admin-user", federatedtypes.CreateFederatedCredential{+ Name: "Unsafe wildcard",+ IssuerURL: "https://token.actions.githubusercontent.com",+ Audiences: []string{"arcane-ci"},+ SubjectMatch: "*",+ MatchType: federatedtypes.MatchTypeGlob,+ RoleID: "role-federated-viewer",+ TokenTTLSeconds: 900,+ })++ require.Error(t, err)+ require.True(t, common.IsErrorFederatedCredentialInvalid(err), "unexpected error: %v", err)+}diff --git a/backend/internal/services/playwright_service.go b/backend/internal/services/playwright_service.goindex d3ea9553d..6552a6c1f 100644--- a/backend/internal/services/playwright_service.go+++ b/backend/internal/services/playwright_service.go@@ -6,21 +6,27 @@ import ("context""fmt""log/slog"+ "strings"+ "github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/pkg/authz""github.com/getarcaneapp/arcane/backend/pkg/pagination""github.com/getarcaneapp/arcane/types/apikey"+ "github.com/google/uuid"+ "gorm.io/gorm")type PlaywrightService struct {- apiKeyService *ApiKeyService- userService *UserService+ apiKeyService *ApiKeyService+ userService *UserService+ federatedCredentialService *FederatedCredentialService}-func NewPlaywrightService(apiKeyService *ApiKeyService, userService *UserService) *PlaywrightService {+func NewPlaywrightService(apiKeyService *ApiKeyService, userService *UserService, federatedCredentialService *FederatedCredentialService) *PlaywrightService {return &PlaywrightService{- apiKeyService: apiKeyService,- userService: userService,+ apiKeyService: apiKeyService,+ userService: userService,+ federatedCredentialService: federatedCredentialService,}}@@ -92,3 +98,58 @@ func (ps *PlaywrightService) DeleteAllTestApiKeys(ctx context.Context) error {slog.Info("Playwright: Test API keys deleted", "count", len(apiKeys))return nil}++func (ps *PlaywrightService) CreateTestFederatedCredential(ctx context.Context, issuerURL string, audiences []string, subject string, roleID string, tokenTTLSeconds int) (string, error) {+ if ps.federatedCredentialService == nil || ps.federatedCredentialService.db == nil {+ return "", fmt.Errorf("federated credential service is not available")+ }+ if strings.TrimSpace(issuerURL) == "" || strings.TrimSpace(subject) == "" || strings.TrimSpace(roleID) == "" || len(audiences) == 0 {+ return "", fmt.Errorf("issuerUrl, subject, roleId, and audiences are required")+ }+ if tokenTTLSeconds <= 0 {+ tokenTTLSeconds = 600+ }++ var credentialID string+ err := ps.federatedCredentialService.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ serviceUser := models.User{+ Username: "svc_federated_e2e_" + strings.ReplaceAll(uuid.NewString(), "-", ""),+ IsServiceAccount: true,+ }+ if err := tx.Create(&serviceUser).Error; err != nil {+ return fmt.Errorf("failed to create federated e2e user: %w", err)+ }++ credential := models.FederatedCredential{+ Name: "Playwright Federated Credential",+ Enabled: true,+ IssuerURL: strings.TrimRight(strings.TrimSpace(issuerURL), "/"),+ Audiences: models.StringSlice(audiences),+ SubjectClaim: "sub",+ SubjectMatch: strings.TrimSpace(subject),+ MatchType: models.FederatedCredentialMatchExact,+ RoleID: strings.TrimSpace(roleID),+ IdentityUserID: serviceUser.ID,+ TokenTTLSeconds: tokenTTLSeconds,+ }+ if err := tx.Create(&credential).Error; err != nil {+ return fmt.Errorf("failed to create federated e2e credential: %w", err)+ }++ assignment := models.UserRoleAssignment{+ UserID: serviceUser.ID,+ RoleID: credential.RoleID,+ Source: models.RoleAssignmentSourceManual,+ }+ if err := tx.Create(&assignment).Error; err != nil {+ return fmt.Errorf("failed to create federated e2e role assignment: %w", err)+ }++ credentialID = credential.ID+ return nil+ })+ if err != nil {+ return "", err+ }+ return credentialID, nil+}diff --git a/backend/internal/services/role_service.go b/backend/internal/services/role_service.goindex 6ecbc3c16..8b9869da9 100644--- a/backend/internal/services/role_service.go+++ b/backend/internal/services/role_service.go@@ -17,6 +17,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/pkg/authz""github.com/getarcaneapp/arcane/backend/pkg/pagination"+ pkgutils "github.com/getarcaneapp/arcane/backend/pkg/utils""github.com/getarcaneapp/arcane/backend/pkg/utils/cache""github.com/getarcaneapp/arcane/backend/pkg/utils/dbutil"roletypes "github.com/getarcaneapp/arcane/types/role"@@ -569,9 +570,10 @@ func (s *RoleService) ReplaceOidcAssignments(ctx context.Context, userID string,func (s *RoleService) CountGlobalAdminsExcludingUser(ctx context.Context, excludedUserID string) (int, error) {var count int64if err := s.db.WithContext(ctx).- Model(&models.UserRoleAssignment{}).- Distinct("user_id").- Where("role_id = ? AND environment_id IS NULL AND user_id <> ?", authz.BuiltInRoleAdmin, excludedUserID).+ Table("user_role_assignments AS ura").+ Joins("JOIN users ON users.id = ura.user_id").+ Distinct("ura.user_id").+ Where("ura.role_id = ? AND ura.environment_id IS NULL AND ura.user_id <> ? AND users.is_service_account = ?", authz.BuiltInRoleAdmin, excludedUserID, false).Count(&count).Error; err != nil {return 0, fmt.Errorf("failed to count global admins: %w", err)}@@ -580,9 +582,10 @@ func (s *RoleService) CountGlobalAdminsExcludingUser(ctx context.Context, excludfunc (s *RoleService) countGlobalAdminsInternal(_ context.Context, tx *gorm.DB) (int, error) {var count int64- if err := tx.Model(&models.UserRoleAssignment{}).- Distinct("user_id").- Where("role_id = ? AND environment_id IS NULL", authz.BuiltInRoleAdmin).+ if err := tx.Table("user_role_assignments AS ura").+ Joins("JOIN users ON users.id = ura.user_id").+ Distinct("ura.user_id").+ Where("ura.role_id = ? AND ura.environment_id IS NULL AND users.is_service_account = ?", authz.BuiltInRoleAdmin, false).Count(&count).Error; err != nil {return 0, fmt.Errorf("failed to count global admins: %w", err)}@@ -913,6 +916,26 @@ func (s *RoleService) ValidatePermissionsAgainstCaller(caller *authz.PermissionSif err := validatePermissionsInternal(desired); err != nil {return err}+ return validatePermissionSetAgainstCallerInternal(caller, desired, "")+}++// ValidateRoleAssignmentAgainstCaller rejects assigning a role at the requested+// scope when the caller does not hold every permission in that role at that+// same scope.+func (s *RoleService) ValidateRoleAssignmentAgainstCaller(ctx context.Context, caller *authz.PermissionSet, roleID string, environmentID *string) error {+ role, err := s.GetRole(ctx, roleID)+ if err != nil {+ return err+ }++ desired := []string(role.Permissions)+ if err := validatePermissionsInternal(desired); err != nil {+ return err+ }+ return validatePermissionSetAgainstCallerInternal(caller, desired, pkgutils.DerefString(environmentID))+}++func validatePermissionSetAgainstCallerInternal(caller *authz.PermissionSet, desired []string, environmentID string) error {if caller == nil {if len(desired) == 0 {return nil@@ -923,7 +946,7 @@ func (s *RoleService) ValidatePermissionsAgainstCaller(caller *authz.PermissionSreturn nil}for _, p := range desired {- if !caller.Allows(p, "") {+ if !caller.Allows(p, environmentID) {return &common.RolePermissionEscalationError{Perm: p}}}diff --git a/backend/internal/services/session_service.go b/backend/internal/services/session_service.goindex 88ded2334..ef3d7d39b 100644--- a/backend/internal/services/session_service.go+++ b/backend/internal/services/session_service.go@@ -37,6 +37,7 @@ func (s *SessionService) CreateSession(ctx context.Context, userID string, expirRefreshTokenHash: refreshHash,UserAgent: pkgutils.StringPtrFromTrimmed(meta.UserAgent),IPAddress: pkgutils.StringPtrFromTrimmed(meta.IPAddress),+ Source: models.UserSessionSourceLocal,LastUsedAt: now,ExpiresAt: expiresAt,}@@ -48,6 +49,26 @@ func (s *SessionService) CreateSession(ctx context.Context, userID string, expirreturn session, refreshJTI, nil}+func (s *SessionService) CreateFederatedSession(ctx context.Context, userID string, expiresAt time.Time, credentialID string) (*models.UserSession, error) {+ refreshHash := hashRefreshJTIInternal(uuid.NewString())+ now := time.Now()++ session := &models.UserSession{+ UserID: userID,+ RefreshTokenHash: refreshHash,+ Source: models.UserSessionSourceFederated,+ FederatedCredentialID: pkgutils.StringPtrFromTrimmed(credentialID),+ LastUsedAt: now,+ ExpiresAt: expiresAt,+ }++ if err := s.db.WithContext(ctx).Create(session).Error; err != nil {+ return nil, fmt.Errorf("failed to create federated user session: %w", err)+ }++ return session, nil+}+func (s *SessionService) GetSessionByID(ctx context.Context, sessionID string) (*models.UserSession, error) {if strings.TrimSpace(sessionID) == "" {return nil, ErrInvalidTokendiff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.goindex 93149354e..b18601d56 100644--- a/backend/internal/services/user_service.go+++ b/backend/internal/services/user_service.go@@ -403,7 +403,9 @@ func (s *UserService) UpgradePasswordHash(ctx context.Context, userID, passwordfunc (s *UserService) ListUsersPaginated(ctx context.Context, params pagination.QueryParams) ([]user.User, pagination.Response, error) {var users []models.User- query := s.db.WithContext(ctx).Model(&models.User{})+ query := s.db.WithContext(ctx).+ Model(&models.User{}).+ Where("is_service_account = ?", false)if term := strings.TrimSpace(params.Search); term != "" {searchPattern := "%" + term + "%"diff --git a/backend/pkg/authz/catalog.go b/backend/pkg/authz/catalog.goindex 07939cce1..fd75a75f5 100644--- a/backend/pkg/authz/catalog.go+++ b/backend/pkg/authz/catalog.go@@ -42,6 +42,13 @@ var permissionCatalog = []PermissionCatalogResource{{"update", PermApiKeysUpdate, "Update", ""},{"delete", PermApiKeysDelete, "Delete", ""},}},+ {"federated", "Federated Credentials", PermissionScopeGlobal, []PermissionCatalogAction{+ {"list", PermFederatedList, "List", ""},+ {"read", PermFederatedRead, "Read", ""},+ {"create", PermFederatedCreate, "Create", ""},+ {"update", PermFederatedUpdate, "Update", ""},+ {"delete", PermFederatedDelete, "Delete", ""},+ }},{"settings", "Settings", PermissionScopeGlobal, []PermissionCatalogAction{{"read", PermSettingsRead, "Read", ""},{"write", PermSettingsWrite, "Write", ""},diff --git a/backend/pkg/authz/permissions.go b/backend/pkg/authz/permissions.goindex 30285539f..94db9a094 100644--- a/backend/pkg/authz/permissions.go+++ b/backend/pkg/authz/permissions.go@@ -38,6 +38,12 @@ const (PermApiKeysUpdate = "apikeys:update"PermApiKeysDelete = "apikeys:delete"+ PermFederatedList = "federated:list"+ PermFederatedRead = "federated:read"+ PermFederatedCreate = "federated:create"+ PermFederatedUpdate = "federated:update"+ PermFederatedDelete = "federated:delete"+PermSettingsRead = "settings:read"PermSettingsWrite = "settings:write"@@ -257,6 +263,7 @@ func BuiltInEditorPermissions() []string {PermUsersList, PermUsersRead,PermRolesList, PermRolesRead,PermApiKeysList, PermApiKeysRead,+ PermFederatedList, PermFederatedRead,PermSettingsRead,PermEnvironmentsList, PermEnvironmentsRead, PermEnvironmentsSync,PermRegistriesList, PermRegistriesRead,@@ -312,6 +319,7 @@ func BuiltInViewerPermissions() []string {PermUsersList, PermUsersRead,PermRolesList, PermRolesRead,PermApiKeysList, PermApiKeysRead,+ PermFederatedList, PermFederatedRead,PermSettingsRead,PermEnvironmentsList, PermEnvironmentsRead,PermRegistriesList, PermRegistriesRead,diff --git a/backend/resources/migrations/postgres/056_add_federated_credentials.down.sql b/backend/resources/migrations/postgres/056_add_federated_credentials.down.sqlnew file mode 100644index 000000000..b52076a30--- /dev/null+++ b/backend/resources/migrations/postgres/056_add_federated_credentials.down.sql@@ -0,0 +1,13 @@+DROP INDEX IF EXISTS idx_user_sessions_federated_credential_id;+ALTER TABLE user_sessions DROP COLUMN IF EXISTS federated_credential_id;+ALTER TABLE user_sessions DROP COLUMN IF EXISTS source;+ALTER TABLE users DROP COLUMN IF EXISTS is_service_account;++DROP INDEX IF EXISTS idx_federated_credentials_role_id;+DROP INDEX IF EXISTS idx_federated_credentials_identity_user_id;+DROP INDEX IF EXISTS idx_federated_credentials_enabled;+DROP INDEX IF EXISTS idx_federated_credentials_issuer_url;+DROP INDEX IF EXISTS idx_federated_token_replays_expires_at;+DROP INDEX IF EXISTS idx_federated_token_replays_issuer_url;+DROP TABLE IF EXISTS federated_token_replays;+DROP TABLE IF EXISTS federated_credentials;diff --git a/backend/resources/migrations/postgres/056_add_federated_credentials.up.sql b/backend/resources/migrations/postgres/056_add_federated_credentials.up.sqlnew file mode 100644index 000000000..23b7e3318--- /dev/null+++ b/backend/resources/migrations/postgres/056_add_federated_credentials.up.sql@@ -0,0 +1,42 @@+CREATE TABLE IF NOT EXISTS federated_credentials (+ id TEXT PRIMARY KEY,+ name TEXT NOT NULL,+ description TEXT,+ enabled BOOLEAN NOT NULL DEFAULT FALSE,+ issuer_url TEXT NOT NULL,+ audiences TEXT NOT NULL,+ subject_claim TEXT NOT NULL DEFAULT 'sub',+ subject_match TEXT NOT NULL,+ match_type TEXT NOT NULL DEFAULT 'exact',+ role_id TEXT NOT NULL REFERENCES roles(id),+ environment_id TEXT REFERENCES environments(id) ON DELETE SET NULL,+ identity_user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,+ token_ttl_seconds INTEGER NOT NULL DEFAULT 900,+ last_used_at TIMESTAMPTZ,+ expires_at TIMESTAMPTZ,+ created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,+ updated_at TIMESTAMPTZ+);++CREATE INDEX IF NOT EXISTS idx_federated_credentials_issuer_url ON federated_credentials(issuer_url);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_enabled ON federated_credentials(enabled);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_identity_user_id ON federated_credentials(identity_user_id);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_role_id ON federated_credentials(role_id);++CREATE TABLE IF NOT EXISTS federated_token_replays (+ id TEXT PRIMARY KEY,+ token_hash TEXT NOT NULL UNIQUE,+ issuer_url TEXT NOT NULL,+ expires_at TIMESTAMPTZ NOT NULL,+ created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,+ updated_at TIMESTAMPTZ+);++CREATE INDEX IF NOT EXISTS idx_federated_token_replays_issuer_url ON federated_token_replays(issuer_url);+CREATE INDEX IF NOT EXISTS idx_federated_token_replays_expires_at ON federated_token_replays(expires_at);++ALTER TABLE users ADD COLUMN IF NOT EXISTS is_service_account BOOLEAN NOT NULL DEFAULT FALSE;+ALTER TABLE user_sessions ADD COLUMN IF NOT EXISTS source TEXT;+ALTER TABLE user_sessions ADD COLUMN IF NOT EXISTS federated_credential_id TEXT REFERENCES federated_credentials(id) ON DELETE SET NULL;++CREATE INDEX IF NOT EXISTS idx_user_sessions_federated_credential_id ON user_sessions(federated_credential_id);diff --git a/backend/resources/migrations/sqlite/056_add_federated_credentials.down.sql b/backend/resources/migrations/sqlite/056_add_federated_credentials.down.sqlnew file mode 100644index 000000000..2173d5356--- /dev/null+++ b/backend/resources/migrations/sqlite/056_add_federated_credentials.down.sql@@ -0,0 +1,13 @@+DROP INDEX IF EXISTS idx_user_sessions_federated_credential_id;+ALTER TABLE user_sessions DROP COLUMN federated_credential_id;+ALTER TABLE user_sessions DROP COLUMN source;+ALTER TABLE users DROP COLUMN is_service_account;++DROP INDEX IF EXISTS idx_federated_credentials_role_id;+DROP INDEX IF EXISTS idx_federated_credentials_identity_user_id;+DROP INDEX IF EXISTS idx_federated_credentials_enabled;+DROP INDEX IF EXISTS idx_federated_credentials_issuer_url;+DROP INDEX IF EXISTS idx_federated_token_replays_expires_at;+DROP INDEX IF EXISTS idx_federated_token_replays_issuer_url;+DROP TABLE IF EXISTS federated_token_replays;+DROP TABLE IF EXISTS federated_credentials;diff --git a/backend/resources/migrations/sqlite/056_add_federated_credentials.up.sql b/backend/resources/migrations/sqlite/056_add_federated_credentials.up.sqlnew file mode 100644index 000000000..9c171e97d--- /dev/null+++ b/backend/resources/migrations/sqlite/056_add_federated_credentials.up.sql@@ -0,0 +1,45 @@+CREATE TABLE IF NOT EXISTS federated_credentials (+ id TEXT PRIMARY KEY,+ name TEXT NOT NULL,+ description TEXT,+ enabled BOOLEAN NOT NULL DEFAULT 0,+ issuer_url TEXT NOT NULL,+ audiences TEXT NOT NULL,+ subject_claim TEXT NOT NULL DEFAULT 'sub',+ subject_match TEXT NOT NULL,+ match_type TEXT NOT NULL DEFAULT 'exact',+ role_id TEXT NOT NULL,+ environment_id TEXT,+ identity_user_id TEXT NOT NULL,+ token_ttl_seconds INTEGER NOT NULL DEFAULT 900,+ last_used_at DATETIME,+ expires_at DATETIME,+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,+ updated_at DATETIME,+ FOREIGN KEY (role_id) REFERENCES roles(id),+ FOREIGN KEY (environment_id) REFERENCES environments(id) ON DELETE SET NULL,+ FOREIGN KEY (identity_user_id) REFERENCES users(id) ON DELETE CASCADE+);++CREATE INDEX IF NOT EXISTS idx_federated_credentials_issuer_url ON federated_credentials(issuer_url);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_enabled ON federated_credentials(enabled);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_identity_user_id ON federated_credentials(identity_user_id);+CREATE INDEX IF NOT EXISTS idx_federated_credentials_role_id ON federated_credentials(role_id);++CREATE TABLE IF NOT EXISTS federated_token_replays (+ id TEXT PRIMARY KEY,+ token_hash TEXT NOT NULL UNIQUE,+ issuer_url TEXT NOT NULL,+ expires_at DATETIME NOT NULL,+ created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,+ updated_at DATETIME+);++CREATE INDEX IF NOT EXISTS idx_federated_token_replays_issuer_url ON federated_token_replays(issuer_url);+CREATE INDEX IF NOT EXISTS idx_federated_token_replays_expires_at ON federated_token_replays(expires_at);++ALTER TABLE users ADD COLUMN is_service_account BOOLEAN NOT NULL DEFAULT 0;+ALTER TABLE user_sessions ADD COLUMN source TEXT;+ALTER TABLE user_sessions ADD COLUMN federated_credential_id TEXT REFERENCES federated_credentials(id) ON DELETE SET NULL;++CREATE INDEX IF NOT EXISTS idx_user_sessions_federated_credential_id ON user_sessions(federated_credential_id);diff --git a/cli/internal/ci/ci_detect.go b/cli/internal/ci/ci_detect.gonew file mode 100644index 000000000..cf922b027--- /dev/null+++ b/cli/internal/ci/ci_detect.go@@ -0,0 +1,116 @@+package ci++import (+ "context"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "strings"+ "time"+)++const (+ ProviderAuto = "auto"+ ProviderGitHub = "github"+ ProviderGitLab = "gitlab"+ ProviderGeneric = "generic"+)++// DetectToken resolves a CI-issued OIDC token from the requested provider.+func DetectToken(ctx context.Context, provider string, audience string, getenv func(string) string, httpClient *http.Client) (string, string, error) {+ provider = normalizeFederatedProviderInternal(provider)+ if getenv == nil {+ getenv = func(string) string { return "" }+ }+ if httpClient == nil {+ httpClient = &http.Client{Timeout: 10 * time.Second}+ }++ switch provider {+ case ProviderAuto:+ if token, err := mintGitHubActionsTokenInternal(ctx, audience, getenv, httpClient); err == nil {+ return token, ProviderGitHub, nil+ }+ if token := strings.TrimSpace(getenv("CI_JOB_JWT_V2")); token != "" {+ return token, ProviderGitLab, nil+ }+ return "", "", fmt.Errorf("no supported CI OIDC token source detected")+ case ProviderGitHub:+ token, err := mintGitHubActionsTokenInternal(ctx, audience, getenv, httpClient)+ if err != nil {+ return "", "", err+ }+ return token, ProviderGitHub, nil+ case ProviderGitLab:+ token := strings.TrimSpace(getenv("CI_JOB_JWT_V2"))+ if token == "" {+ return "", "", fmt.Errorf("CI_JOB_JWT_V2 is not set; pass a GitLab id_tokens value with --token")+ }+ return token, ProviderGitLab, nil+ case ProviderGeneric:+ return "", "", fmt.Errorf("generic provider requires --token, --token-file, or --token-stdin")+ default:+ return "", "", fmt.Errorf("unsupported federated provider %q", provider)+ }+}++func mintGitHubActionsTokenInternal(ctx context.Context, audience string, getenv func(string) string, httpClient *http.Client) (string, error) {+ requestURL := strings.TrimSpace(getenv("ACTIONS_ID_TOKEN_REQUEST_URL"))+ requestToken := strings.TrimSpace(getenv("ACTIONS_ID_TOKEN_REQUEST_TOKEN"))+ if requestURL == "" || requestToken == "" {+ return "", fmt.Errorf("GitHub Actions OIDC request environment is not set")+ }++ parsedURL, err := url.Parse(requestURL)+ if err != nil {+ return "", fmt.Errorf("invalid GitHub Actions OIDC request URL: %w", err)+ }+ if strings.TrimSpace(audience) != "" {+ q := parsedURL.Query()+ q.Set("audience", strings.TrimSpace(audience))+ parsedURL.RawQuery = q.Encode()+ }++ req, err := http.NewRequestWithContext(ctx, http.MethodGet, parsedURL.String(), nil)+ if err != nil {+ return "", fmt.Errorf("failed to create GitHub Actions OIDC request: %w", err)+ }+ req.Header.Set("Authorization", "Bearer "+requestToken)+ req.Header.Set("Accept", "application/json")++ resp, err := httpClient.Do(req)+ if err != nil {+ return "", fmt.Errorf("failed to request GitHub Actions OIDC token: %w", err)+ }+ defer func() { _ = resp.Body.Close() }()++ body, err := io.ReadAll(io.LimitReader(resp.Body, 4096))+ if err != nil {+ return "", fmt.Errorf("failed to read GitHub Actions OIDC response: %w", err)+ }+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return "", fmt.Errorf("GitHub Actions OIDC request failed with status %d", resp.StatusCode)+ }++ var payload struct {+ Value string `json:"value"`+ }+ if err := json.Unmarshal(body, &payload); err != nil {+ return "", fmt.Errorf("failed to parse GitHub Actions OIDC response: %w", err)+ }+ token := strings.TrimSpace(payload.Value)+ if token == "" {+ return "", fmt.Errorf("GitHub Actions OIDC response did not include a token")+ }+ return token, nil+}++func normalizeFederatedProviderInternal(provider string) string {+ provider = strings.ToLower(strings.TrimSpace(provider))+ if provider == "" {+ return ProviderAuto+ }+ return provider+}diff --git a/cli/internal/ci/ci_detect_test.go b/cli/internal/ci/ci_detect_test.gonew file mode 100644index 000000000..c33c08381--- /dev/null+++ b/cli/internal/ci/ci_detect_test.go@@ -0,0 +1,64 @@+package ci++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/stretchr/testify/require"+)++func TestDetectFederatedTokenFromGitHubActionsInternal(t *testing.T) {+ t.Parallel()++ var gotAudience string+ var gotAuth string+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ gotAudience = r.URL.Query().Get("audience")+ gotAuth = r.Header.Get("Authorization")+ require.NoError(t, json.NewEncoder(w).Encode(map[string]string{"value": "github.jwt"}))+ }))+ t.Cleanup(server.Close)++ env := map[string]string{+ "ACTIONS_ID_TOKEN_REQUEST_URL": server.URL + "?api-version=2",+ "ACTIONS_ID_TOKEN_REQUEST_TOKEN": "request-token",+ }+ token, provider, err := DetectToken(context.Background(), "auto", "https://arcane.example.com", envGetterFromMapInternal(env), server.Client())++ require.NoError(t, err)+ require.Equal(t, "github.jwt", token)+ require.Equal(t, "github", provider)+ require.Equal(t, "https://arcane.example.com", gotAudience)+ require.Equal(t, "Bearer request-token", gotAuth)+}++func TestDetectFederatedTokenFromGitLabLegacyInternal(t *testing.T) {+ t.Parallel()++ token, provider, err := DetectToken(context.Background(), "auto", "https://arcane.example.com", envGetterFromMapInternal(map[string]string{+ "CI_JOB_JWT_V2": "gitlab.jwt",+ }), http.DefaultClient)++ require.NoError(t, err)+ require.Equal(t, "gitlab.jwt", token)+ require.Equal(t, "gitlab", provider)+}++func TestDetectFederatedTokenProviderMismatchInternal(t *testing.T) {+ t.Parallel()++ _, _, err := DetectToken(context.Background(), "github", "aud", envGetterFromMapInternal(map[string]string{+ "CI_JOB_JWT_V2": "gitlab.jwt",+ }), http.DefaultClient)++ require.Error(t, err)+}++func envGetterFromMapInternal(values map[string]string) func(string) string {+ return func(key string) string {+ return values[key]+ }+}diff --git a/cli/internal/client/client.go b/cli/internal/client/client.goindex 990868431..c23935c6c 100644--- a/cli/internal/client/client.go+++ b/cli/internal/client/client.go@@ -32,6 +32,7 @@ import ("net""net/http""net/url"+ "os""strings""time"@@ -160,6 +161,11 @@ func NewFromConfig() (*Client, error) {if strings.TrimSpace(state.EnvOverride) != "" {cfg.DefaultEnvironment = strings.TrimSpace(state.EnvOverride)}+ if token := strings.TrimSpace(os.Getenv("ARCANE_TOKEN")); token != "" {+ cfg.JWTToken = token+ cfg.APIKey = ""+ cfg.RefreshToken = ""+ }c, err := New(cfg)if err != nil {return nil, err@@ -180,6 +186,11 @@ func NewFromConfigUnauthenticated() (*Client, error) {if strings.TrimSpace(state.EnvOverride) != "" {cfg.DefaultEnvironment = strings.TrimSpace(state.EnvOverride)}+ if token := strings.TrimSpace(os.Getenv("ARCANE_TOKEN")); token != "" {+ cfg.JWTToken = token+ cfg.APIKey = ""+ cfg.RefreshToken = ""+ }c, err := NewUnauthenticated(cfg)if err != nil {return nil, errdiff --git a/cli/internal/config/config.go b/cli/internal/config/config.goindex 67d6582b5..e7379cec6 100644--- a/cli/internal/config/config.go+++ b/cli/internal/config/config.go@@ -178,6 +178,7 @@ func Load() (*types.Config, error) {v.SetConfigType("yaml")v.SetDefault("server_url", "http://localhost:3552")v.SetDefault("default_environment", "0")+ v.SetDefault("federated_audience", "")v.SetDefault("log_level", "info")if err := v.ReadInConfig(); err != nil {return nil, fmt.Errorf("failed to parse config file: %w", err)@@ -232,6 +233,9 @@ func Save(c *types.Config) error {if cfg.DefaultEnvironment != "" {v.Set("default_environment", cfg.DefaultEnvironment)}+ if cfg.FederatedAudience != "" {+ v.Set("federated_audience", cfg.FederatedAudience)+ }if cfg.LogLevel != "" {v.Set("log_level", cfg.LogLevel)}@@ -301,6 +305,7 @@ func InitDefaultFile() (bool, error) {v.Set("jwt_token", "")v.Set("refresh_token", "")v.Set("default_environment", "0")+ v.Set("federated_audience", "")v.Set("log_level", "info")v.Set("pagination.default.limit", defaultPaginationInitLimit)diff --git a/cli/internal/types/config.go b/cli/internal/types/config.goindex 589d63bee..0737b761b 100644--- a/cli/internal/types/config.go+++ b/cli/internal/types/config.go@@ -88,6 +88,8 @@ type Config struct {RefreshToken string `yaml:"refresh_token,omitempty" mapstructure:"refresh_token"` //nolint:gosec // persisted config schema requires this field name// DefaultEnvironment is the default environment ID to useDefaultEnvironment string `yaml:"default_environment,omitempty" mapstructure:"default_environment"`+ // FederatedAudience is the default token audience for `arcane-cli auth federated`+ FederatedAudience string `yaml:"federated_audience,omitempty" mapstructure:"federated_audience"`// LogLevel is the logging level (debug, info, warn, error, fatal, panic)LogLevel string `yaml:"log_level,omitempty" mapstructure:"log_level"`// CLIUpdateChannel controls which channel self-update uses (stable or next).diff --git a/cli/internal/types/endpoints.go b/cli/internal/types/endpoints.goindex 4e55c50d5..7cc1233d8 100644--- a/cli/internal/types/endpoints.go+++ b/cli/internal/types/endpoints.go@@ -9,10 +9,11 @@ type ArcaneApiEndpoints struct {VersionEndpoint string// Authentication- AuthLogoutEndpoint string- AuthMeEndpoint string- AuthPasswordEndpoint string- AuthRefreshEndpoint string+ AuthLogoutEndpoint string+ AuthMeEndpoint string+ AuthPasswordEndpoint string+ AuthRefreshEndpoint string+ AuthFederatedEndpoint string// OIDCOIDCDeviceCodeEndpoint string@@ -178,10 +179,11 @@ var Endpoints = ArcaneApiEndpoints{ //nolint:gosec // static endpoint paths; autVersionEndpoint: "/api/version",// Authentication- AuthLogoutEndpoint: "/api/auth/logout",- AuthMeEndpoint: "/api/auth/me",- AuthPasswordEndpoint: "/api/auth/password",- AuthRefreshEndpoint: "/api/auth/refresh",+ AuthLogoutEndpoint: "/api/auth/logout",+ AuthMeEndpoint: "/api/auth/me",+ AuthPasswordEndpoint: "/api/auth/password",+ AuthRefreshEndpoint: "/api/auth/refresh",+ AuthFederatedEndpoint: "/api/auth/federated/token",// OIDCOIDCDeviceCodeEndpoint: "/api/oidc/device/code",@@ -342,10 +344,11 @@ var Endpoints = ArcaneApiEndpoints{ //nolint:gosec // static endpoint paths; aut}// Auth endpoints-func (e ArcaneApiEndpoints) AuthLogout() string { return e.AuthLogoutEndpoint }-func (e ArcaneApiEndpoints) AuthMe() string { return e.AuthMeEndpoint }-func (e ArcaneApiEndpoints) AuthPassword() string { return e.AuthPasswordEndpoint }-func (e ArcaneApiEndpoints) AuthRefresh() string { return e.AuthRefreshEndpoint }+func (e ArcaneApiEndpoints) AuthLogout() string { return e.AuthLogoutEndpoint }+func (e ArcaneApiEndpoints) AuthMe() string { return e.AuthMeEndpoint }+func (e ArcaneApiEndpoints) AuthPassword() string { return e.AuthPasswordEndpoint }+func (e ArcaneApiEndpoints) AuthRefresh() string { return e.AuthRefreshEndpoint }+func (e ArcaneApiEndpoints) AuthFederated() string { return e.AuthFederatedEndpoint }// OIDC endpointsfunc (e ArcaneApiEndpoints) OIDCDeviceCode() string { return e.OIDCDeviceCodeEndpoint }diff --git a/cli/pkg/auth/federated.go b/cli/pkg/auth/federated.gonew file mode 100644index 000000000..9e6592b74--- /dev/null+++ b/cli/pkg/auth/federated.go@@ -0,0 +1,233 @@+package auth++import (+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "os"+ "strings"+ "time"++ "github.com/getarcaneapp/arcane/cli/internal/ci"+ "github.com/getarcaneapp/arcane/cli/internal/client"+ "github.com/getarcaneapp/arcane/cli/internal/cmdutil"+ "github.com/getarcaneapp/arcane/cli/internal/config"+ "github.com/getarcaneapp/arcane/cli/internal/output"+ "github.com/getarcaneapp/arcane/cli/internal/types"+ federatedtypes "github.com/getarcaneapp/arcane/types/federated"+ "github.com/spf13/cobra"+)++const maxFederatedErrorBody = 4096++var federatedCmd = &cobra.Command{+ Use: "federated",+ Short: "Exchange a CI OIDC token for a short-lived Arcane token",+ SilenceUsage: true,+ Long: `Exchange an external OIDC token for a short-lived Arcane bearer token.++GitHub Actions example:+ permissions: { id-token: write, contents: read }+ steps:+ - run: |+ eval "$(arcane-cli auth federated \+ --server https://arcane.example.com \+ --audience https://arcane.example.com --export)"+ - run: arcane-cli projects up my-app`,+ RunE: func(cmd *cobra.Command, args []string) error {+ server, _ := cmd.Flags().GetString("server")+ audience, _ := cmd.Flags().GetString("audience")+ provider, _ := cmd.Flags().GetString("provider")+ persist, _ := cmd.Flags().GetBool("persist")+ exportOutput, _ := cmd.Flags().GetBool("export")++ if cmdutil.JSONOutputEnabled(cmd) && exportOutput {+ return fmt.Errorf("--json and --export cannot be used together")+ }++ cfg, err := config.Load()+ if err != nil {+ return fmt.Errorf("failed to load config: %w", err)+ }+ if strings.TrimSpace(server) != "" {+ cfg.ServerURL = strings.TrimSpace(server)+ }+ if strings.TrimSpace(audience) == "" {+ audience = cfg.FederatedAudience+ }++ subjectToken, tokenSource, err := resolveFederatedSubjectTokenInternal(cmd, provider, audience)+ if err != nil {+ return err+ }++ c, err := client.NewUnauthenticated(cfg)+ if err != nil {+ return err+ }++ tokenResp, err := exchangeFederatedTokenInternal(cmd, c, strings.TrimSpace(subjectToken), strings.TrimSpace(audience))+ if err != nil {+ return err+ }+ if tokenResp.AccessToken == "" {+ return fmt.Errorf("federated token exchange failed: empty access token")+ }++ expiresAt := time.Now().UTC().Add(time.Duration(tokenResp.ExpiresIn) * time.Second)++ if persist {+ cfg.JWTToken = tokenResp.AccessToken+ cfg.APIKey = ""+ cfg.RefreshToken = ""+ if err := config.Save(cfg); err != nil {+ return fmt.Errorf("failed to save federated token: %w", err)+ }+ }++ switch {+ case cmdutil.JSONOutputEnabled(cmd):+ resultBytes, err := json.MarshalIndent(map[string]any{+ "token": tokenResp.AccessToken,+ "tokenType": tokenResp.TokenType,+ "expiresIn": tokenResp.ExpiresIn,+ "expiresAt": expiresAt.Format(time.RFC3339),+ "issuedTokenType": tokenResp.IssuedTokenType,+ "source": tokenSource,+ "persisted": persist,+ }, "", " ")+ if err != nil {+ return fmt.Errorf("failed to marshal JSON: %w", err)+ }+ fmt.Println(string(resultBytes))+ case exportOutput:+ fmt.Printf("export ARCANE_TOKEN=%s\n", shellQuoteInternal(tokenResp.AccessToken))+ fmt.Printf("export ARCANE_TOKEN_EXPIRES_AT=%s\n", shellQuoteInternal(expiresAt.Format(time.RFC3339)))+ default:+ output.Success("Federated token exchange successful")+ output.KeyValue("Token source", tokenSource)+ output.KeyValue("Expires at", expiresAt.Format(time.RFC3339))+ if persist {+ path, _ := config.ConfigPath()+ output.KeyValue("JWT token saved to config", path)+ } else {+ output.Info("Use --export, --json, or --persist to consume the token.")+ }+ }++ return nil+ },+}++func init() {+ AuthCmd.AddCommand(federatedCmd)++ federatedCmd.Flags().String("server", "", "Arcane server URL for this exchange")+ federatedCmd.Flags().String("audience", "", "Audience to request from the external OIDC provider")+ federatedCmd.Flags().String("token", "", "External OIDC token to exchange")+ federatedCmd.Flags().String("token-file", "", "Path to a file containing the external OIDC token")+ federatedCmd.Flags().Bool("token-stdin", false, "Read the external OIDC token from stdin")+ federatedCmd.Flags().String("provider", ci.ProviderAuto, "OIDC token source: auto, github, gitlab, or generic")+ federatedCmd.Flags().Bool("persist", false, "Persist the exchanged Arcane token in CLI config")+ federatedCmd.Flags().Bool("export", false, "Print shell exports for ARCANE_TOKEN and ARCANE_TOKEN_EXPIRES_AT")+ federatedCmd.Flags().Bool("json", false, "Output in JSON format")+}++func resolveFederatedSubjectTokenInternal(cmd *cobra.Command, provider string, audience string) (string, string, error) {+ token, _ := cmd.Flags().GetString("token")+ if strings.TrimSpace(token) != "" {+ return strings.TrimSpace(token), "flag", nil+ }++ tokenFile, _ := cmd.Flags().GetString("token-file")+ if strings.TrimSpace(tokenFile) != "" {+ data, err := os.ReadFile(strings.TrimSpace(tokenFile))+ if err != nil {+ return "", "", fmt.Errorf("failed to read token file: %w", err)+ }+ token = strings.TrimSpace(string(data))+ if token == "" {+ return "", "", fmt.Errorf("token file is empty")+ }+ return token, "file", nil+ }++ tokenStdin, _ := cmd.Flags().GetBool("token-stdin")+ if tokenStdin || stdinHasDataInternal() {+ data, err := io.ReadAll(os.Stdin)+ if err != nil {+ return "", "", fmt.Errorf("failed to read token from stdin: %w", err)+ }+ token = strings.TrimSpace(string(data))+ if token == "" {+ return "", "", fmt.Errorf("stdin token is empty")+ }+ return token, "stdin", nil+ }++ return ci.DetectToken(cmd.Context(), provider, audience, os.Getenv, &http.Client{Timeout: 10 * time.Second})+}++func exchangeFederatedTokenInternal(cmd *cobra.Command, c *client.Client, subjectToken string, audience string) (*federatedtypes.FederatedTokenResponse, error) {+ form := url.Values{}+ form.Set("grant_type", federatedtypes.TokenExchangeGrantType)+ form.Set("subject_token", subjectToken)+ form.Set("subject_token_type", federatedtypes.SubjectTokenTypeJWT)+ form.Set("requested_token_type", federatedtypes.RequestedTokenTypeAccessJWT)+ if strings.TrimSpace(audience) != "" {+ form.Set("audience", strings.TrimSpace(audience))+ }++ resp, err := c.RequestRaw(cmd.Context(), http.MethodPost, types.Endpoints.AuthFederated(), strings.NewReader(form.Encode()), map[string]string{+ "Content-Type": "application/x-www-form-urlencoded",+ })+ if err != nil {+ return nil, fmt.Errorf("federated token exchange failed: %w", err)+ }+ defer func() { _ = resp.Body.Close() }()++ body, err := io.ReadAll(io.LimitReader(resp.Body, maxFederatedErrorBody))+ if err != nil {+ return nil, fmt.Errorf("failed to read federated token response: %w", err)+ }+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ return nil, fmt.Errorf("federated token exchange failed (status %d): %s", resp.StatusCode, redactedFederatedExchangeMessageInternal(body))+ }++ var tokenResp federatedtypes.FederatedTokenResponse+ if err := json.Unmarshal(body, &tokenResp); err != nil {+ return nil, fmt.Errorf("failed to parse federated token response: %w", err)+ }+ return &tokenResp, nil+}++func redactedFederatedExchangeMessageInternal(body []byte) string {+ var oauthErr struct {+ Error string `json:"error"`+ ErrorDescription string `json:"error_description"` //nolint:tagliatelle // RFC 6749 wire shape is snake_case.+ }+ if err := json.Unmarshal(body, &oauthErr); err == nil {+ if strings.TrimSpace(oauthErr.ErrorDescription) != "" {+ return strings.TrimSpace(oauthErr.ErrorDescription)+ }+ if strings.TrimSpace(oauthErr.Error) != "" {+ return strings.TrimSpace(oauthErr.Error)+ }+ }+ msg := strings.TrimSpace(string(body))+ if msg == "" {+ return "request rejected"+ }+ return msg+}++func stdinHasDataInternal() bool {+ info, err := os.Stdin.Stat()+ return err == nil && (info.Mode()&os.ModeCharDevice) == 0+}++func shellQuoteInternal(value string) string {+ return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"+}diff --git a/cli/pkg/config/cmd.go b/cli/pkg/config/cmd.goindex bf2a33103..367c0d6db 100644--- a/cli/pkg/config/cmd.go+++ b/cli/pkg/config/cmd.go@@ -16,13 +16,14 @@ import ()var (- setServerURL string- setAPIKey string- setJWTToken string- setEnvironment string- setLogLevel string- setDefaultLimit int- setResourceLimit []string+ setServerURL string+ setAPIKey string+ setJWTToken string+ setEnvironment string+ setFederatedAudience string+ setLogLevel string+ setDefaultLimit int+ setResourceLimit []string)// ConfigCmd is the command for managing API configuration@@ -47,6 +48,7 @@ var configShowCmd = &cobra.Command{fmt.Printf("JWT Token: %s\n", maskAPIKey(cfg.JWTToken))fmt.Printf("Refresh Token: %s\n", maskAPIKey(cfg.RefreshToken))fmt.Printf("Default Environment: %s\n", maskIfEmpty(cfg.DefaultEnvironment, "0 (local)"))+ fmt.Printf("Federated Audience: %s\n", maskIfEmpty(cfg.FederatedAudience, "(not set)"))fmt.Printf("Log Level: %s\n", maskIfEmpty(cfg.LogLevel, "info (default)"))fmt.Printf("CLI Update Channel: %s\n", maskIfEmpty(cfg.CLIUpdateChannel, "(auto)"))fmt.Printf("Pagination Default: %s\n", maskIfEmpty(intToString(cfg.Pagination.Default.Limit), "(not set)"))@@ -273,6 +275,7 @@ func init() {configSetCmd.Flags().StringVar(&setAPIKey, "api-key", "", "API key for authentication")configSetCmd.Flags().StringVar(&setJWTToken, "jwt-token", "", "JWT access token for authentication (Bearer token)")configSetCmd.Flags().StringVar(&setEnvironment, "environment", "", "Default environment ID")+ configSetCmd.Flags().StringVar(&setFederatedAudience, "federated-audience", "", "Default audience for federated authentication")configSetCmd.Flags().StringVar(&setLogLevel, "log-level", "", "Default log level (debug, info, warn, error)")configSetCmd.Flags().IntVar(&setDefaultLimit, "default-limit", 0, "Global default list limit for paginated resources (0 clears)")configSetCmd.Flags().StringSliceVar(&setResourceLimit, "resource-limit", nil, "Per-resource list limit in the form resource=limit (repeatable, 0 clears)")@@ -348,6 +351,12 @@ func applyConfigSetFlags(cmd *cobra.Command, cfg *clitypes.Config) (bool, error)updated = true}+ if setFederatedAudience != "" {+ cfg.FederatedAudience = setFederatedAudience+ fmt.Printf("Set federated_audience = %s\n", setFederatedAudience)+ updated = true+ }+if setLogLevel != "" {cfg.LogLevel = setLogLevelfmt.Printf("Set log_level = %s\n", setLogLevel)@@ -431,6 +440,10 @@ func applyConfigSetArg(cfg *clitypes.Config, key, value string) (bool, error) {cfg.DefaultEnvironment = valuefmt.Printf("Set default_environment = %s\n", value)return true, nil+ case "federated-audience", "federated_audience", "audience":+ cfg.FederatedAudience = value+ fmt.Printf("Set federated_audience = %s\n", value)+ return true, nilcase "log-level", "loglevel", "log_level":cfg.LogLevel = valuefmt.Printf("Set log_level = %s\n", value)@@ -481,7 +494,7 @@ func applyConfigSetArg(cfg *clitypes.Config, key, value string) (bool, error) {return applyResourceLimitByKey(cfg, key, resource, value)}- return false, fmt.Errorf("unknown config key %q. Supported keys include server-url, api-key, jwt-token, environment, log-level, default-limit, resource-limit, and pagination.resources.<resource>.limit", key)+ return false, fmt.Errorf("unknown config key %q. Supported keys include server-url, api-key, jwt-token, environment, federated-audience, log-level, default-limit, resource-limit, and pagination.resources.<resource>.limit", key)}func applyResourceLimitByKey(cfg *clitypes.Config, key, resourceValue, limitValue string) (bool, error) {diff --git a/frontend/messages/en.json b/frontend/messages/en.jsonindex a4c3d9dc6..958d44b93 100644--- a/frontend/messages/en.json+++ b/frontend/messages/en.json@@ -2620,6 +2620,64 @@"api_key_bulk_delete_failed": "Failed to delete {count} API key(s)","api_key_bulk_delete_static_skipped": "Skipped {count} static API key(s). Only deletable keys will be removed.","api_key_bulk_delete_static_only": "Static API keys cannot be deleted.",+ "_comment_federated_credentials": "=== FEDERATED CREDENTIALS ===",+ "federated_credential_page_title": "Federated Credentials",+ "federated_credential_page_description": "Trust external OIDC workload identities and exchange them for short-lived Arcane tokens.",+ "federated_credential_create_title": "Create Federated Credential",+ "federated_credential_edit_title": "Edit Federated Credential",+ "federated_credential_create_description": "Create a trust rule for a CI or workload OIDC identity.",+ "federated_credential_edit_description": "Update the trust rule \"{name}\"",+ "federated_credential_create_button": "Create Federated Credential",+ "federated_credential_created_success": "Federated credential \"{name}\" created successfully",+ "federated_credential_create_failed": "Failed to create federated credential \"{name}\"",+ "federated_credential_updated_success": "Federated credential \"{name}\" updated successfully",+ "federated_credential_update_failed": "Failed to update federated credential \"{name}\"",+ "federated_credential_delete_title": "Delete Federated Credential \"{name}\"?",+ "federated_credential_delete_message": "Are you sure you want to delete the federated credential \"{name}\"? This action cannot be undone.",+ "federated_credential_delete_selected_title": "Delete {count} Federated Credential(s)?",+ "federated_credential_delete_selected_message": "Are you sure you want to delete {count} federated credential(s)? This action cannot be undone.",+ "federated_credential_delete_failed": "Failed to delete federated credential \"{name}\"",+ "federated_credential_delete_success": "Federated credential \"{name}\" deleted successfully",+ "federated_credential_bulk_delete_success": "Successfully deleted {count} federated credential(s)",+ "federated_credential_bulk_delete_failed": "Failed to delete {count} federated credential(s)",+ "federated_credential_name_label": "Name",+ "federated_credential_name_placeholder": "GitHub Actions production deploy",+ "federated_credential_description_placeholder": "Optional description",+ "federated_credential_issuer_label": "Issuer",+ "federated_credential_issuer_placeholder": "https://token.actions.githubusercontent.com",+ "federated_credential_issuer_description": "The HTTPS OIDC issuer that signs the workload token.",+ "federated_credential_issuer_required": "Enter a valid issuer URL",+ "federated_credential_audiences_label": "Audiences",+ "federated_credential_audiences_placeholder": "https://arcane.example.com",+ "federated_credential_audiences_description": "One audience per line or comma. The external token must contain one of these audiences.",+ "federated_credential_audience_required": "Enter at least one audience",+ "federated_credential_subject_claim_label": "Subject Claim",+ "federated_credential_subject_claim_placeholder": "sub",+ "federated_credential_subject_match_label": "Subject Match",+ "federated_credential_subject_match_placeholder": "repo:owner/repo:ref:refs/heads/main",+ "federated_credential_subject_match_description": "Exact subject value or an anchored glob pattern.",+ "federated_credential_subject_required": "Enter a subject match",+ "federated_credential_match_type_label": "Match Type",+ "federated_credential_match_exact": "Exact",+ "federated_credential_match_glob": "Glob",+ "federated_credential_role_required": "Select a role",+ "federated_credential_role_scope_column": "Role / Scope",+ "federated_credential_scope_global_option": "Global",+ "federated_credential_ttl_label": "Token TTL",+ "federated_credential_ttl_description": "Issued Arcane token lifetime in seconds.",+ "federated_credential_ttl_min": "Token TTL must be at least 60 seconds",+ "federated_credential_ttl_max": "Token TTL cannot exceed 3600 seconds",+ "federated_credential_expires_at_label": "Credential Expires",+ "federated_credential_expires_at_description": "Optional date when this trust rule stops accepting exchanges.",+ "federated_credential_enabled_label": "Enabled",+ "federated_credential_enabled_description": "Allow matching workloads to exchange tokens with this credential.",+ "federated_credential_status_expired": "Expired",+ "federated_credential_last_used": "Last Used",+ "federated_credential_wildcard_warning_title": "Broad subject match",+ "federated_credential_wildcard_warning_description": "Use the narrowest subject pattern that fits the workload.",+ "federated_credential_instructions_title": "Federated Credential Created",+ "federated_credential_instructions_description": "Use the Arcane CLI to request an external OIDC token and exchange it during automation.",+ "federated_credential_instructions_snippet_label": "GitHub Actions snippet","common_done": "Done","common_important": "Important","select_a_date": "Select a date",diff --git a/frontend/src/lib/components/sheets/federated-credential-form-sheet.svelte b/frontend/src/lib/components/sheets/federated-credential-form-sheet.sveltenew file mode 100644index 000000000..332f37e77--- /dev/null+++ b/frontend/src/lib/components/sheets/federated-credential-form-sheet.svelte@@ -0,0 +1,309 @@+<script lang="ts">+ import * as ResponsiveDialog from '$lib/components/ui/responsive-dialog/index.js';+ import * as Select from '$lib/components/ui/select';+ import * as Alert from '$lib/components/ui/alert';+ import { ArcaneButton } from '$lib/components/arcane-button/index.js';+ import FormInput from '$lib/components/form/form-input.svelte';+ import { Label } from '$lib/components/ui/label';+ import { Switch } from '$lib/components/ui/switch/index.js';+ import type { CreateFederatedCredential, FederatedCredential, FederatedCredentialMatchType, Role } from '$lib/types/auth';+ import type { Environment } from '$lib/types/environment';+ import { z } from 'zod/v4';+ import { createForm, preventDefault } from '$lib/utils/settings';+ import * as m from '$lib/paraglide/messages.js';+ import { InfoIcon } from '$lib/icons';++ type Props = {+ open: boolean;+ credentialToEdit: FederatedCredential | null;+ roles: Role[];+ environments: Environment[];+ isLoading: boolean;+ onSubmit: (data: { credential: CreateFederatedCredential; isEditMode: boolean; credentialId?: string }) => void;+ };++ let { open = $bindable(false), credentialToEdit, roles, environments, isLoading, onSubmit }: Props = $props();++ const GLOBAL_OPTION_ID = 'global';+ const MATCH_TYPES: { value: FederatedCredentialMatchType; label: string }[] = [+ { value: 'exact', label: m.federated_credential_match_exact() },+ { value: 'glob', label: m.federated_credential_match_glob() }+ ];++ const isEditMode = $derived(!!credentialToEdit);++ const envOptions = $derived([+ { id: GLOBAL_OPTION_ID, name: m.federated_credential_scope_global_option() },+ ...environments.map((env) => ({ id: env.id, name: env.name }))+ ]);++ const formSchema = z.object({+ name: z.string().min(1, m.common_field_required({ field: m.common_name() })),+ description: z.string().optional(),+ enabled: z.boolean(),+ issuerUrl: z.url().min(1, m.federated_credential_issuer_required()),+ audience: z.string().min(1, m.federated_credential_audience_required()),+ subjectClaim: z.string().optional(),+ subjectMatch: z.string().min(1, m.federated_credential_subject_required()),+ matchType: z.enum(['exact', 'glob']),+ roleId: z.string().min(1, m.federated_credential_role_required()),+ environmentId: z.string(),+ tokenTtlSeconds: z.coerce+ .number()+ .int()+ .min(60, m.federated_credential_ttl_min())+ .max(3600, m.federated_credential_ttl_max()),+ expiresAt: z.date().optional()+ });++ const formData = $derived({+ name: credentialToEdit?.name ?? '',+ description: credentialToEdit?.description ?? '',+ enabled: credentialToEdit?.enabled ?? false,+ issuerUrl: credentialToEdit?.issuerUrl ?? '',+ audience: credentialToEdit?.audiences?.join('\n') ?? '',+ subjectClaim: credentialToEdit?.subjectClaim ?? 'sub',+ subjectMatch: credentialToEdit?.subjectMatch ?? '',+ matchType: credentialToEdit?.matchType ?? ('exact' as FederatedCredentialMatchType),+ roleId: credentialToEdit?.roleId ?? roles[0]?.id ?? '',+ environmentId: credentialToEdit?.environmentId ?? GLOBAL_OPTION_ID,+ tokenTtlSeconds: credentialToEdit?.tokenTtlSeconds ?? 900,+ expiresAt: credentialToEdit?.expiresAt ? new Date(credentialToEdit.expiresAt) : undefined+ });++ const { inputs, ...form } = $derived(createForm<typeof formSchema>(formSchema, formData));++ const hasWildcardWarning = $derived.by(() => {+ const value = String($inputs.subjectMatch.value ?? '').trim();+ return shouldWarnSubjectMatchInternal(value);+ });++ function shouldWarnSubjectMatchInternal(value: string): boolean {+ if (value === '' || value === '*') {+ return value === '*';+ }+ return value.endsWith('/*') || /^repo:[^/]+\/\*(?::|$)/.test(value);+ }++ function envSelectedLabel(value: string): string {+ return envOptions.find((o) => o.id === value)?.name ?? m.common_select_option();+ }++ function roleSelectedLabel(value: string): string {+ return roles.find((r) => r.id === value)?.name ?? m.common_select_option();+ }++ function matchTypeLabel(value: string): string {+ return MATCH_TYPES.find((option) => option.value === value)?.label ?? m.common_select_option();+ }++ function parseAudiencesInternal(value: string): string[] {+ return value+ .split(/[\n,]/)+ .map((entry) => entry.trim())+ .filter(Boolean);+ }++ function handleSubmit() {+ const data = form.validate();+ if (!data) return;++ const payload: CreateFederatedCredential = {+ name: data.name,+ description: data.description || undefined,+ enabled: data.enabled,+ issuerUrl: data.issuerUrl,+ audiences: parseAudiencesInternal(data.audience),+ subjectClaim: data.subjectClaim || 'sub',+ subjectMatch: data.subjectMatch,+ matchType: data.matchType,+ roleId: data.roleId,+ environmentId: data.environmentId === GLOBAL_OPTION_ID ? undefined : data.environmentId,+ tokenTtlSeconds: data.tokenTtlSeconds,+ expiresAt: data.expiresAt ? data.expiresAt.toISOString() : undefined+ };++ onSubmit({ credential: payload, isEditMode, credentialId: credentialToEdit?.id });+ }++ function handleOpenChange(newOpenState: boolean) {+ open = newOpenState;+ }+</script>++<ResponsiveDialog.Root+ bind:open+ onOpenChange={handleOpenChange}+ variant="sheet"+ title={isEditMode ? m.federated_credential_edit_title() : m.federated_credential_create_title()}+ description={isEditMode+ ? m.federated_credential_edit_description({ name: credentialToEdit?.name ?? m.common_unknown() })+ : m.federated_credential_create_description()}+ contentClass="sm:max-w-[560px]"+>+ {#snippet children()}+ <form onsubmit={preventDefault(handleSubmit)} novalidate class="grid gap-4 py-6">+ <FormInput+ label={m.federated_credential_name_label()}+ type="text"+ placeholder={m.federated_credential_name_placeholder()}+ bind:input={$inputs.name}+ disabled={isLoading}+ />+ <FormInput+ label={m.common_description()}+ type="text"+ placeholder={m.federated_credential_description_placeholder()}+ bind:input={$inputs.description}+ disabled={isLoading}+ />+ <FormInput+ label={m.federated_credential_issuer_label()}+ type="text"+ placeholder={m.federated_credential_issuer_placeholder()}+ description={m.federated_credential_issuer_description()}+ bind:input={$inputs.issuerUrl}+ disabled={isLoading}+ />+ <FormInput+ label={m.federated_credential_audiences_label()}+ type="textarea"+ rows={3}+ placeholder={m.federated_credential_audiences_placeholder()}+ description={m.federated_credential_audiences_description()}+ bind:input={$inputs.audience}+ disabled={isLoading}+ />+ <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">+ <FormInput+ label={m.federated_credential_subject_claim_label()}+ type="text"+ placeholder={m.federated_credential_subject_claim_placeholder()}+ bind:input={$inputs.subjectClaim}+ disabled={isLoading}+ />+ <div class="space-y-2">+ <Label for="federated-match-type" class="mb-0">{m.federated_credential_match_type_label()}</Label>+ <Select.Root type="single" bind:value={$inputs.matchType.value} disabled={isLoading}>+ <Select.Trigger id="federated-match-type" class="w-full">+ <span>{matchTypeLabel($inputs.matchType.value)}</span>+ </Select.Trigger>+ <Select.Content>+ {#each MATCH_TYPES as option (option.value)}+ <Select.Item value={option.value} label={option.label}>+ {option.label}+ </Select.Item>+ {/each}+ </Select.Content>+ </Select.Root>+ </div>+ </div>+ <FormInput+ label={m.federated_credential_subject_match_label()}+ type="text"+ placeholder={m.federated_credential_subject_match_placeholder()}+ description={m.federated_credential_subject_match_description()}+ bind:input={$inputs.subjectMatch}+ disabled={isLoading}+ />+ {#if hasWildcardWarning}+ <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">+ <InfoIcon class="h-4 w-4 text-amber-600 dark:text-amber-500" />+ <Alert.Title class="text-amber-900 dark:text-amber-100">{m.federated_credential_wildcard_warning_title()}</Alert.Title>+ <Alert.Description class="text-amber-800 dark:text-amber-200">+ {m.federated_credential_wildcard_warning_description()}+ </Alert.Description>+ </Alert.Root>+ {/if}+ <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">+ <div class="space-y-2">+ <Label for="federated-role" class="mb-0">{m.common_role()}</Label>+ <Select.Root type="single" bind:value={$inputs.roleId.value} disabled={isLoading}>+ <Select.Trigger id="federated-role" class="w-full {$inputs.roleId.error ? 'border-destructive' : ''}">+ <span>{roleSelectedLabel($inputs.roleId.value)}</span>+ </Select.Trigger>+ <Select.Content>+ {#each roles as role (role.id)}+ <Select.Item value={role.id} label={role.name}>+ <div class="flex flex-col items-start gap-0.5">+ <span class="font-medium">{role.name}</span>+ {#if role.description}+ <span class="text-muted-foreground text-xs">{role.description}</span>+ {/if}+ </div>+ </Select.Item>+ {/each}+ </Select.Content>+ </Select.Root>+ {#if $inputs.roleId.error}+ <p class="text-destructive text-xs font-medium">{$inputs.roleId.error}</p>+ {/if}+ </div>+ <div class="space-y-2">+ <Label for="federated-env" class="mb-0">{m.common_scope()}</Label>+ <Select.Root type="single" bind:value={$inputs.environmentId.value} disabled={isLoading}>+ <Select.Trigger id="federated-env" class="w-full">+ <span>{envSelectedLabel($inputs.environmentId.value)}</span>+ </Select.Trigger>+ <Select.Content>+ {#each envOptions as option (option.id)}+ <Select.Item value={option.id} label={option.name}>+ {option.name}+ </Select.Item>+ {/each}+ </Select.Content>+ </Select.Root>+ </div>+ </div>+ <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">+ <FormInput+ label={m.federated_credential_ttl_label()}+ type="number"+ description={m.federated_credential_ttl_description()}+ bind:input={$inputs.tokenTtlSeconds}+ disabled={isLoading}+ />+ <FormInput+ label={m.federated_credential_expires_at_label()}+ type="date"+ description={m.federated_credential_expires_at_description()}+ bind:input={$inputs.expiresAt}+ disabled={isLoading}+ />+ </div>+ <div class="flex items-center space-x-2">+ <Switch id="federated-enabled" bind:checked={$inputs.enabled.value} disabled={isLoading} />+ <div class="grid gap-1.5 leading-none">+ <Label for="federated-enabled" class="mb-0 text-sm leading-none font-medium">+ {m.federated_credential_enabled_label()}+ </Label>+ <p class="text-muted-foreground text-[0.8rem]">+ {m.federated_credential_enabled_description()}+ </p>+ </div>+ </div>+ </form>+ {/snippet}++ {#snippet footer()}+ <div class="flex w-full flex-row gap-2">+ <ArcaneButton+ action="cancel"+ tone="outline"+ type="button"+ class="flex-1"+ onclick={() => (open = false)}+ disabled={isLoading}+ />+ <ArcaneButton+ action={isEditMode ? 'save' : 'create'}+ type="submit"+ class="flex-1"+ disabled={isLoading}+ loading={isLoading}+ onclick={handleSubmit}+ customLabel={isEditMode ? m.common_save() : m.common_create()}+ />+ </div>+ {/snippet}+</ResponsiveDialog.Root>diff --git a/frontend/src/lib/query/query-keys.ts b/frontend/src/lib/query/query-keys.tsindex 415b8900f..0872ec87a 100644--- a/frontend/src/lib/query/query-keys.ts+++ b/frontend/src/lib/query/query-keys.ts@@ -32,6 +32,10 @@ export const queryKeys = {all: ['api-keys'] as const,list: (options: SearchPaginationSortRequest) => ['api-keys', stableSerialize(options)] as const},+ federatedCredentials: {+ all: ['federated-credentials'] as const,+ list: (options: SearchPaginationSortRequest) => ['federated-credentials', stableSerialize(options)] as const+ },environments: {all: ['environments'] as const,list: (options: SearchPaginationSortRequest) => ['environments', stableSerialize(options)] as const,diff --git a/frontend/src/lib/services/federated-credential-service.ts b/frontend/src/lib/services/federated-credential-service.tsnew file mode 100644index 000000000..0fb0e3030--- /dev/null+++ b/frontend/src/lib/services/federated-credential-service.ts@@ -0,0 +1,30 @@+import BaseAPIService from './api-service';+import type { CreateFederatedCredential, FederatedCredential, UpdateFederatedCredential } from '$lib/types/auth';+import type { Paginated, SearchPaginationSortRequest } from '$lib/types/shared';+import { transformPaginationParams } from '$lib/utils/tables';++export default class FederatedCredentialAPIService extends BaseAPIService {+ async list(options?: SearchPaginationSortRequest): Promise<Paginated<FederatedCredential>> {+ const params = transformPaginationParams(options);+ const res = await this.api.get('/federated-credentials', { params });+ return res.data;+ }++ async get(id: string): Promise<FederatedCredential> {+ return this.handleResponse(this.api.get(`/federated-credentials/${id}`)) as Promise<FederatedCredential>;+ }++ async create(credential: CreateFederatedCredential): Promise<FederatedCredential> {+ return this.handleResponse(this.api.post('/federated-credentials', credential)) as Promise<FederatedCredential>;+ }++ async update(id: string, credential: UpdateFederatedCredential): Promise<FederatedCredential> {+ return this.handleResponse(this.api.put(`/federated-credentials/${id}`, credential)) as Promise<FederatedCredential>;+ }++ async delete(id: string): Promise<void> {+ return this.handleResponse(this.api.delete(`/federated-credentials/${id}`)) as Promise<void>;+ }+}++export const federatedCredentialService = new FederatedCredentialAPIService();diff --git a/frontend/src/lib/types/auth.ts b/frontend/src/lib/types/auth.tsindex c008fbe52..461fcd829 100644--- a/frontend/src/lib/types/auth.ts+++ b/frontend/src/lib/types/auth.ts@@ -198,3 +198,47 @@ export type UpdateApiKey = {expiresAt?: string;permissions?: ApiKeyPermissionGrant[];};++// --- Federated credentials ---++export type FederatedCredentialMatchType = 'exact' | 'glob';++export type FederatedCredential = {+ id: string;+ name: string;+ description?: string;+ enabled: boolean;+ issuerUrl: string;+ audiences: string[];+ subjectClaim: string;+ subjectMatch: string;+ matchType: FederatedCredentialMatchType;+ roleId: string;+ environmentId?: string;+ identityUserId: string;+ tokenTtlSeconds: number;+ lastUsedAt?: string;+ expiresAt?: string;+ createdAt: string;+ updatedAt?: string;+ serviceUsername?: string;+ roleName?: string;+ environmentName?: string;+};++export type CreateFederatedCredential = {+ name: string;+ description?: string;+ enabled: boolean;+ issuerUrl: string;+ audiences: string[];+ subjectClaim?: string;+ subjectMatch: string;+ matchType?: FederatedCredentialMatchType;+ roleId: string;+ environmentId?: string;+ tokenTtlSeconds?: number;+ expiresAt?: string;+};++export type UpdateFederatedCredential = Partial<CreateFederatedCredential>;diff --git a/frontend/src/routes/(app)/settings/authentication/+page.svelte b/frontend/src/routes/(app)/settings/authentication/+page.svelteindex 9ce97ebfe..6191914d7 100644--- a/frontend/src/routes/(app)/settings/authentication/+page.svelte+++ b/frontend/src/routes/(app)/settings/authentication/+page.svelte@@ -18,7 +18,10 @@import * as Collapsible from '$lib/components/ui/collapsible';import SettingsRow from '$lib/components/settings/settings-row.svelte';import { cn } from '$lib/utils';+ import * as Tabs from '$lib/components/ui/tabs/index.js';+ import { TabBar, type TabItem } from '$lib/components/tab-bar/index.js';import OidcMappingTable from './oidc-mapping-table.svelte';+ import FederatedCredentialsTab from './federated-credentials-tab.svelte';import OidcMappingFormSheet from '$lib/components/sheets/oidc-mapping-form-sheet.svelte';import type { OidcRoleMapping, CreateOidcRoleMapping, UpdateOidcRoleMapping } from '$lib/types/auth';import { oidcMappingService } from '$lib/services/oidc-mapping-service';@@ -28,12 +31,40 @@import IfPermitted from '$lib/components/if-permitted.svelte';let { data }: PageProps = $props();+ type AuthenticationTab = 'settings' | 'federated';+ let activeTab: AuthenticationTab = $state(untrack(() => (data.activeAuthTab === 'federated' ? 'federated' : 'settings')));+ const formState = getContext('settingsFormState') as+ | {+ hasChanges: boolean;+ isLoading: boolean;+ saveFunction: (() => Promise<void>) | null;+ resetFunction: (() => void) | null;+ }+ | undefined;++ const authenticationTabItems = $derived.by(+ () =>+ [+ {+ value: 'settings',+ label: m.authentication_title()+ },+ {+ value: 'federated',+ label: m.federated_credential_page_title()+ }+ ] satisfies TabItem[]+ );++ function handleAuthenticationTabChange(value: string) {+ activeTab = value === 'federated' ? 'federated' : 'settings';+ }// OIDC role mappings — co-located with the OIDC settings so admins// configure the groups claim and the mappings that read it in one place.- let oidcMappings = $state<OidcRoleMapping[]>(untrack(() => data.oidcMappings ?? []));+ let oidcMappings: OidcRoleMapping[] = $state(untrack(() => data.oidcMappings ?? []));let mappingSheetOpen = $state(false);- let editingMapping = $state<OidcRoleMapping | null>(null);+ let editingMapping: OidcRoleMapping | null = $state(null);let mappingSaving = $state(false);async function refreshMappings() {@@ -272,7 +303,6 @@$effect(() => {settingsForm.registerFormActions(customSubmit, customReset);- const formState = getContext('settingsFormState') as any;if (formState) {formState.hasChanges = hasAuthenticationChanges;}@@ -283,307 +313,330 @@title={m.authentication_title()}description={m.authentication_description()}icon={LockIcon}- pageType="form"- showReadOnlyTag={isReadOnly}+ pageType={activeTab === 'settings' ? 'form' : 'management'}+ showReadOnlyTag={activeTab === 'settings' && isReadOnly}>{#snippet mainContent()}- <fieldset disabled={isReadOnly} class="relative space-y-8">- <div class="space-y-4">- <h3 class="text-base font-semibold">{m.security_authentication_heading()}</h3>-- {#if isAutoLoginEnabled}- <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">- <InfoIcon class="h-4 w-4 text-amber-600 dark:text-amber-500" />- <Alert.Title class="text-amber-900 dark:text-amber-100">{m.security_auto_login_enabled_title()}</Alert.Title>- <Alert.Description class="text-amber-800 dark:text-amber-200">- {m.security_auto_login_enabled_description()}- </Alert.Description>- </Alert.Root>- {:else}- <div class="divide-border/40 divide-y [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0">- <SettingsRow label={m.security_local_auth_label()} description={m.security_local_auth_description()} layout="inline">- <Switch- id="localAuthSwitch"- bind:checked={$formInputs.authLocalEnabled.value}- onCheckedChange={handleLocalSwitchChange}- />- </SettingsRow>-- <Collapsible.Root bind:open={oidcConfigOpen}>- <SettingsRow label={m.security_oidc_auth_label()} description={m.security_oidc_auth_description()} layout="inline">- {#snippet labelExtra()}- {#if isOidcEnvForced}- <div class="mt-2">- <ArcaneTooltip.Root>- <ArcaneTooltip.Trigger>- <span- class="inline-flex items-center gap-1.5 rounded-full bg-amber-100 px-2.5 py-1 text-xs font-medium text-amber-800 ring-1 ring-amber-200 dark:bg-amber-900/50 dark:text-amber-200 dark:ring-amber-800"- >- {#if isOidcForcedDisabled}- {m.security_server_disabled_via_server()}- {:else}- {m.security_server_configured()}- {/if}- </span>- </ArcaneTooltip.Trigger>- <ArcaneTooltip.Content side="top">- {#if isOidcForcedDisabled}- {m.security_oidc_forced_disabled_tooltip()}- {:else}- {m.security_oidc_forced_managed_tooltip()}- {/if}- </ArcaneTooltip.Content>- </ArcaneTooltip.Root>- </div>- {/if}- {/snippet}- <div class="flex flex-col items-end gap-2">+ <Tabs.Root value={activeTab}>+ <TabBar items={authenticationTabItems} value={activeTab} onValueChange={handleAuthenticationTabChange} />++ <Tabs.Content value="settings" class="mt-6">+ <fieldset disabled={isReadOnly} class="relative space-y-8">+ <div class="space-y-4">+ <h3 class="text-base font-semibold">{m.security_authentication_heading()}</h3>++ {#if isAutoLoginEnabled}+ <Alert.Root variant="default" class="border-amber-200 bg-amber-50 dark:border-amber-800 dark:bg-amber-950">+ <InfoIcon class="h-4 w-4 text-amber-600 dark:text-amber-500" />+ <Alert.Title class="text-amber-900 dark:text-amber-100">{m.security_auto_login_enabled_title()}</Alert.Title>+ <Alert.Description class="text-amber-800 dark:text-amber-200">+ {m.security_auto_login_enabled_description()}+ </Alert.Description>+ </Alert.Root>+ {:else}+ <div class="divide-border/40 divide-y [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0">+ <SettingsRow+ label={m.security_local_auth_label()}+ description={m.security_local_auth_description()}+ layout="inline"+ ><Switch- id="oidcEnabledSwitch"- disabled={isOidcEnvForced}- bind:checked={$formInputs.oidcEnabled.value}- onCheckedChange={handleOidcEnabledChange}+ id="localAuthSwitch"+ bind:checked={$formInputs.authLocalEnabled.value}+ onCheckedChange={handleLocalSwitchChange}/>- {#if showOidcDetails}- <Collapsible.Trigger- class="text-muted-foreground hover:text-foreground hover:bg-muted/50 inline-flex items-center gap-1.5 rounded-md px-2 py-1 text-xs font-medium transition-colors"- >- <span>{oidcConfigOpen ? m.common_hide() : m.common_show()} {m.common_configuration()}</span>- <ArrowDownIcon class={cn('size-3.5 transition-transform', oidcConfigOpen && 'rotate-180')} />- </Collapsible.Trigger>- {/if}- </div>- </SettingsRow>-- {#if showOidcDetails}- <Collapsible.Content class="mt-4">- <div class="border-border/60 space-y-5 border-l-2 pl-5">- <div class="grid gap-5 sm:grid-cols-2">- <TextInputWithLabel- id="oidcClientId"- label={m.oidc_client_id_label()}- placeholder={m.oidc_client_id_placeholder()}+ </SettingsRow>++ <Collapsible.Root bind:open={oidcConfigOpen}>+ <SettingsRow+ label={m.security_oidc_auth_label()}+ description={m.security_oidc_auth_description()}+ layout="inline"+ >+ {#snippet labelExtra()}+ {#if isOidcEnvForced}+ <div class="mt-2">+ <ArcaneTooltip.Root>+ <ArcaneTooltip.Trigger>+ <span+ class="inline-flex items-center gap-1.5 rounded-full bg-amber-100 px-2.5 py-1 text-xs font-medium text-amber-800 ring-1 ring-amber-200 dark:bg-amber-900/50 dark:text-amber-200 dark:ring-amber-800"+ >+ {#if isOidcForcedDisabled}+ {m.security_server_disabled_via_server()}+ {:else}+ {m.security_server_configured()}+ {/if}+ </span>+ </ArcaneTooltip.Trigger>+ <ArcaneTooltip.Content side="top">+ {#if isOidcForcedDisabled}+ {m.security_oidc_forced_disabled_tooltip()}+ {:else}+ {m.security_oidc_forced_managed_tooltip()}+ {/if}+ </ArcaneTooltip.Content>+ </ArcaneTooltip.Root>+ </div>+ {/if}+ {/snippet}+ <div class="flex flex-col items-end gap-2">+ <Switch+ id="oidcEnabledSwitch"disabled={isOidcEnvForced}- bind:value={$formInputs.oidcClientId.value}- error={$formInputs.oidcClientId.error}- />- <TextInputWithLabel- id="oidcClientSecret"- type="password"- label={m.oidc_client_secret_label()}- placeholder={m.oidc_client_secret_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcClientSecret.value}- error={$formInputs.oidcClientSecret.error}- helpText={m.security_oidc_client_secret_help()}+ bind:checked={$formInputs.oidcEnabled.value}+ onCheckedChange={handleOidcEnabledChange}/>+ {#if showOidcDetails}+ <Collapsible.Trigger+ class="text-muted-foreground hover:text-foreground hover:bg-muted/50 inline-flex items-center gap-1.5 rounded-md px-2 py-1 text-xs font-medium transition-colors"+ >+ <span>{oidcConfigOpen ? m.common_hide() : m.common_show()} {m.common_configuration()}</span>+ <ArrowDownIcon class={cn('size-3.5 transition-transform', oidcConfigOpen && 'rotate-180')} />+ </Collapsible.Trigger>+ {/if}</div>+ </SettingsRow>- <TextInputWithLabel- id="oidcIssuerUrl"- label={m.oidc_issuer_url_label()}- description={m.oidc_issuer_url_description()}- placeholder={m.oidc_issuer_url_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcIssuerUrl.value}- error={$formInputs.oidcIssuerUrl.error}- />-- <div class="grid gap-5 sm:grid-cols-2">- <TextInputWithLabel- id="oidcProviderName"- label={m.oidc_provider_name_label()}- description={m.oidc_provider_name_description()}- placeholder={m.oidc_provider_name_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcProviderName.value}- error={$formInputs.oidcProviderName.error}- />- <TextInputWithLabel- id="oidcProviderLogoUrl"- label={m.oidc_provider_logo_url_label()}- description={m.oidc_provider_logo_url_description()}- placeholder={m.oidc_provider_logo_url_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcProviderLogoUrl.value}- error={$formInputs.oidcProviderLogoUrl.error}- />- </div>-- <TextInputWithLabel- id="oidcScopes"- label={m.oidc_scopes_label()}- placeholder={m.oidc_scopes_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcScopes.value}- error={$formInputs.oidcScopes.error}- />-- <TextInputWithLabel- id="oidcGroupsClaim"- label={m.oidc_groups_claim_label()}- placeholder={m.oidc_groups_claim_placeholder()}- disabled={isOidcEnvForced}- bind:value={$formInputs.oidcGroupsClaim.value}- error={$formInputs.oidcGroupsClaim.error}- helpText={m.oidc_groups_claim_help()}- />-- <div class="divide-border/40 divide-y pt-2 [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0">- <SettingsRow- label={m.security_oidc_merge_accounts_label()}- description={m.security_oidc_merge_accounts_description()}- layout="inline"- >- <Switch- id="oidcMergeAccountsSwitch"+ {#if showOidcDetails}+ <Collapsible.Content class="mt-4">+ <div class="border-border/60 space-y-5 border-l-2 pl-5">+ <div class="grid gap-5 sm:grid-cols-2">+ <TextInputWithLabel+ id="oidcClientId"+ label={m.oidc_client_id_label()}+ placeholder={m.oidc_client_id_placeholder()}+ disabled={isOidcEnvForced}+ bind:value={$formInputs.oidcClientId.value}+ error={$formInputs.oidcClientId.error}+ />+ <TextInputWithLabel+ id="oidcClientSecret"+ type="password"+ label={m.oidc_client_secret_label()}+ placeholder={m.oidc_client_secret_placeholder()}+ disabled={isOidcEnvForced}+ bind:value={$formInputs.oidcClientSecret.value}+ error={$formInputs.oidcClientSecret.error}+ helpText={m.security_oidc_client_secret_help()}+ />+ </div>++ <TextInputWithLabel+ id="oidcIssuerUrl"+ label={m.oidc_issuer_url_label()}+ description={m.oidc_issuer_url_description()}+ placeholder={m.oidc_issuer_url_placeholder()}disabled={isOidcEnvForced}- bind:checked={$formInputs.oidcMergeAccounts.value}- onCheckedChange={handleMergeAccountsChange}+ bind:value={$formInputs.oidcIssuerUrl.value}+ error={$formInputs.oidcIssuerUrl.error}/>- </SettingsRow>-- <SettingsRow- label={m.oidc_skip_tls_verify_label()}- description={m.oidc_skip_tls_verify_description()}- layout="inline"- >- <Switch- id="oidcSkipTlsVerifySwitch"++ <div class="grid gap-5 sm:grid-cols-2">+ <TextInputWithLabel+ id="oidcProviderName"+ label={m.oidc_provider_name_label()}+ description={m.oidc_provider_name_description()}+ placeholder={m.oidc_provider_name_placeholder()}+ disabled={isOidcEnvForced}+ bind:value={$formInputs.oidcProviderName.value}+ error={$formInputs.oidcProviderName.error}+ />+ <TextInputWithLabel+ id="oidcProviderLogoUrl"+ label={m.oidc_provider_logo_url_label()}+ description={m.oidc_provider_logo_url_description()}+ placeholder={m.oidc_provider_logo_url_placeholder()}+ disabled={isOidcEnvForced}+ bind:value={$formInputs.oidcProviderLogoUrl.value}+ error={$formInputs.oidcProviderLogoUrl.error}+ />+ </div>++ <TextInputWithLabel+ id="oidcScopes"+ label={m.oidc_scopes_label()}+ placeholder={m.oidc_scopes_placeholder()}disabled={isOidcEnvForced}- bind:checked={$formInputs.oidcSkipTlsVerify.value}+ bind:value={$formInputs.oidcScopes.value}+ error={$formInputs.oidcScopes.error}/>- </SettingsRow>-- <SettingsRow- label={m.oidc_auto_redirect_label()}- description={m.oidc_auto_redirect_description()}- layout="inline"- >- <Switch- id="oidcAutoRedirectSwitch"++ <TextInputWithLabel+ id="oidcGroupsClaim"+ label={m.oidc_groups_claim_label()}+ placeholder={m.oidc_groups_claim_placeholder()}disabled={isOidcEnvForced}- bind:checked={$formInputs.oidcAutoRedirectToProvider.value}+ bind:value={$formInputs.oidcGroupsClaim.value}+ error={$formInputs.oidcGroupsClaim.error}+ helpText={m.oidc_groups_claim_help()}/>- </SettingsRow>- </div>- <div class="bg-muted/30 rounded-lg border p-4">- <div class="mb-2 flex items-center gap-2">- <InfoIcon class="size-4 text-blue-600" />- <span class="text-sm font-medium">{m.oidc_redirect_uri_title()}</span>- </div>- <p class="text-muted-foreground mb-3 text-sm">{m.oidc_redirect_uri_description()}</p>- <div class="flex items-center gap-2">- <code class="bg-muted flex-1 rounded p-2 font-mono text-xs break-all">{redirectUri}</code>- <CopyButton text={redirectUri} size="sm" variant="outline" class="shrink-0" title={m.common_copy()} />+ <div class="divide-border/40 divide-y pt-2 [&>*]:py-5 [&>*:first-child]:pt-0 [&>*:last-child]:pb-0">+ <SettingsRow+ label={m.security_oidc_merge_accounts_label()}+ description={m.security_oidc_merge_accounts_description()}+ layout="inline"+ >+ <Switch+ id="oidcMergeAccountsSwitch"+ disabled={isOidcEnvForced}+ bind:checked={$formInputs.oidcMergeAccounts.value}+ onCheckedChange={handleMergeAccountsChange}+ />+ </SettingsRow>++ <SettingsRow+ label={m.oidc_skip_tls_verify_label()}+ description={m.oidc_skip_tls_verify_description()}+ layout="inline"+ >+ <Switch+ id="oidcSkipTlsVerifySwitch"+ disabled={isOidcEnvForced}+ bind:checked={$formInputs.oidcSkipTlsVerify.value}+ />+ </SettingsRow>++ <SettingsRow+ label={m.oidc_auto_redirect_label()}+ description={m.oidc_auto_redirect_description()}+ layout="inline"+ >+ <Switch+ id="oidcAutoRedirectSwitch"+ disabled={isOidcEnvForced}+ bind:checked={$formInputs.oidcAutoRedirectToProvider.value}+ />+ </SettingsRow>+ </div>++ <div class="bg-muted/30 rounded-lg border p-4">+ <div class="mb-2 flex items-center gap-2">+ <InfoIcon class="size-4 text-blue-600" />+ <span class="text-sm font-medium">{m.oidc_redirect_uri_title()}</span>+ </div>+ <p class="text-muted-foreground mb-3 text-sm">{m.oidc_redirect_uri_description()}</p>+ <div class="flex items-center gap-2">+ <code class="bg-muted flex-1 rounded p-2 font-mono text-xs break-all">{redirectUri}</code>+ <CopyButton text={redirectUri} size="sm" variant="outline" class="shrink-0" title={m.common_copy()} />+ </div>+ </div></div>+ </Collapsible.Content>+ {/if}+ </Collapsible.Root>+ </div>++ <IfPermitted adminOnly>+ <div class="border-border/40 space-y-4 border-t pt-6">+ <div class="flex items-start justify-between gap-4">+ <div>+ <h4 class="text-sm font-semibold">{m.oidc_role_mappings_title()}</h4>+ <p class="text-muted-foreground mt-0.5 text-xs">{m.oidc_role_mappings_description()}</p></div>+ <ArcaneButton+ action="create"+ tone="outline"+ size="sm"+ onclick={openCreateMapping}+ customLabel={m.common_create_button({ resource: m.resource_oidc_mapping_cap() })}+ /></div>- </Collapsible.Content>- {/if}- </Collapsible.Root>+ {#if oidcMappings.length > 0}+ <OidcMappingTable+ mappings={oidcMappings}+ roles={data.roles}+ environments={data.environments}+ onRefresh={refreshMappings}+ onEdit={openEditMapping}+ />+ {:else}+ <div class="border-border/40 bg-muted/20 rounded-lg border border-dashed p-6 text-center">+ <p class="text-muted-foreground text-sm">{m.oidc_mappings_empty_body()}</p>+ </div>+ {/if}+ </div>+ </IfPermitted>+ {/if}</div>- <IfPermitted adminOnly>- <div class="border-border/40 space-y-4 border-t pt-6">- <div class="flex items-start justify-between gap-4">- <div>- <h4 class="text-sm font-semibold">{m.oidc_role_mappings_title()}</h4>- <p class="text-muted-foreground mt-0.5 text-xs">{m.oidc_role_mappings_description()}</p>- </div>- <ArcaneButton- action="create"- tone="outline"- size="sm"- onclick={openCreateMapping}- customLabel={m.common_create_button({ resource: m.resource_oidc_mapping_cap() })}- />- </div>- {#if oidcMappings.length > 0}- <OidcMappingTable- mappings={oidcMappings}- roles={data.roles}- environments={data.environments}- onRefresh={refreshMappings}- onEdit={openEditMapping}- />- {:else}- <div class="border-border/40 bg-muted/20 rounded-lg border border-dashed p-6 text-center">- <p class="text-muted-foreground text-sm">{m.oidc_mappings_empty_body()}</p>- </div>- {/if}+ <div class="space-y-4">+ <h3 class="text-base font-semibold">{m.security_session_heading()}</h3>+ <div class="max-w-xs">+ <TextInputWithLabel+ id="authSessionTimeout"+ type="number"+ label={m.security_session_timeout_label()}+ description={m.security_session_timeout_description()}+ bind:value={$formInputs.authSessionTimeout.value}+ error={$formInputs.authSessionTimeout.error}+ /></div>- </IfPermitted>- {/if}- </div>-- <div class="space-y-4">- <h3 class="text-base font-semibold">{m.security_session_heading()}</h3>- <div class="max-w-xs">- <TextInputWithLabel- id="authSessionTimeout"- type="number"- label={m.security_session_timeout_label()}- description={m.security_session_timeout_description()}- bind:value={$formInputs.authSessionTimeout.value}- error={$formInputs.authSessionTimeout.error}- />- </div>- </div>-- <div class="space-y-4">- <h3 class="text-base font-semibold">{m.security_password_policy_label()}</h3>- <SettingsRow label={m.security_password_policy_label()} description={m.security_password_policy_description()}>- <div class="grid grid-cols-1 gap-2 sm:grid-cols-3 sm:gap-3" role="group" aria-labelledby="passwordPolicyLabel">- <ArcaneTooltip.Root>- <ArcaneTooltip.Trigger>- <ArcaneButton- action="base"- tone={$formInputs.authPasswordPolicy.value === 'basic' ? 'outline-primary' : 'outline'}- class="h-12 w-full text-xs sm:text-sm"- onclick={() => ($formInputs.authPasswordPolicy.value = 'basic')}- customLabel={m.common_basic()}- />- </ArcaneTooltip.Trigger>- <ArcaneTooltip.Content side="top">- {m.security_password_policy_basic_tooltip()}- </ArcaneTooltip.Content>- </ArcaneTooltip.Root>-- <ArcaneTooltip.Root>- <ArcaneTooltip.Trigger>- <ArcaneButton- action="base"- tone={$formInputs.authPasswordPolicy.value === 'standard' ? 'outline-primary' : 'outline'}- class="h-12 w-full text-xs sm:text-sm"- onclick={() => ($formInputs.authPasswordPolicy.value = 'standard')}- customLabel={m.security_password_policy_standard()}- />- </ArcaneTooltip.Trigger>- <ArcaneTooltip.Content side="top">- {m.security_password_policy_standard_tooltip()}- </ArcaneTooltip.Content>- </ArcaneTooltip.Root>-- <ArcaneTooltip.Root>- <ArcaneTooltip.Trigger>- <ArcaneButton- action="base"- tone={$formInputs.authPasswordPolicy.value === 'strong' ? 'outline-primary' : 'outline'}- class="h-12 w-full text-xs sm:text-sm"- onclick={() => ($formInputs.authPasswordPolicy.value = 'strong')}- customLabel={m.security_password_policy_strong()}- />- </ArcaneTooltip.Trigger>- <ArcaneTooltip.Content side="top">- {m.security_password_policy_strong_tooltip()}- </ArcaneTooltip.Content>- </ArcaneTooltip.Root></div>- </SettingsRow>- </div>- </fieldset>++ <div class="space-y-4">+ <h3 class="text-base font-semibold">{m.security_password_policy_label()}</h3>+ <SettingsRow label={m.security_password_policy_label()} description={m.security_password_policy_description()}>+ <div class="grid grid-cols-1 gap-2 sm:grid-cols-3 sm:gap-3" role="group" aria-labelledby="passwordPolicyLabel">+ <ArcaneTooltip.Root>+ <ArcaneTooltip.Trigger>+ <ArcaneButton+ action="base"+ tone={$formInputs.authPasswordPolicy.value === 'basic' ? 'outline-primary' : 'outline'}+ class="h-12 w-full text-xs sm:text-sm"+ onclick={() => ($formInputs.authPasswordPolicy.value = 'basic')}+ customLabel={m.common_basic()}+ />+ </ArcaneTooltip.Trigger>+ <ArcaneTooltip.Content side="top">+ {m.security_password_policy_basic_tooltip()}+ </ArcaneTooltip.Content>+ </ArcaneTooltip.Root>++ <ArcaneTooltip.Root>+ <ArcaneTooltip.Trigger>+ <ArcaneButton+ action="base"+ tone={$formInputs.authPasswordPolicy.value === 'standard' ? 'outline-primary' : 'outline'}+ class="h-12 w-full text-xs sm:text-sm"+ onclick={() => ($formInputs.authPasswordPolicy.value = 'standard')}+ customLabel={m.security_password_policy_standard()}+ />+ </ArcaneTooltip.Trigger>+ <ArcaneTooltip.Content side="top">+ {m.security_password_policy_standard_tooltip()}+ </ArcaneTooltip.Content>+ </ArcaneTooltip.Root>++ <ArcaneTooltip.Root>+ <ArcaneTooltip.Trigger>+ <ArcaneButton+ action="base"+ tone={$formInputs.authPasswordPolicy.value === 'strong' ? 'outline-primary' : 'outline'}+ class="h-12 w-full text-xs sm:text-sm"+ onclick={() => ($formInputs.authPasswordPolicy.value = 'strong')}+ customLabel={m.security_password_policy_strong()}+ />+ </ArcaneTooltip.Trigger>+ <ArcaneTooltip.Content side="top">+ {m.security_password_policy_strong_tooltip()}+ </ArcaneTooltip.Content>+ </ArcaneTooltip.Root>+ </div>+ </SettingsRow>+ </div>+ </fieldset>+ </Tabs.Content>++ <Tabs.Content value="federated" class="mt-6">+ <FederatedCredentialsTab+ initialFederatedCredentials={data.federatedCredentials}+ initialRequestOptions={data.federatedCredentialRequestOptions}+ roles={data.roles}+ environments={data.environments}+ />+ </Tabs.Content>+ </Tabs.Root>{/snippet}{#snippet additionalContent()}<AlertDialog.Root bind:open={showMergeAccountsAlert}>diff --git a/frontend/src/routes/(app)/settings/authentication/+page.ts b/frontend/src/routes/(app)/settings/authentication/+page.tsindex 285d4a038..2ffb3de9e 100644--- a/frontend/src/routes/(app)/settings/authentication/+page.ts+++ b/frontend/src/routes/(app)/settings/authentication/+page.ts@@ -1,26 +1,59 @@import { oidcMappingService } from '$lib/services/oidc-mapping-service';+import { federatedCredentialService } from '$lib/services/federated-credential-service';import { roleService } from '$lib/services/role-service';import { environmentManagementService } from '$lib/services/env-mgmt-service';+import { queryKeys } from '$lib/query/query-keys';+import type { SearchPaginationSortRequest } from '$lib/types/shared';+import { resolveInitialTableRequest } from '$lib/utils/tables';import type { PageLoad } from './$types';-export const load: PageLoad = async ({ parent }) => {+export const load: PageLoad = async ({ parent, url }) => {const parentData = await parent();+ const { queryClient } = parentData;+ const activeAuthTab = url.searchParams.get('tab') === 'federated' ? 'federated' : 'settings';+ const federatedCredentialRequestOptions = resolveInitialTableRequest('arcane-federated-credentials-table', {+ pagination: {+ page: 1,+ limit: 20+ },+ sort: {+ column: 'createdAt',+ direction: 'desc'+ }+ } satisfies SearchPaginationSortRequest);// OIDC mappings live alongside the OIDC config in this page. We load them// here (instead of a standalone /settings/oidc-mappings route) so admins// configure groups claim + the mappings that read from it in one place.- const [mappings, roles, environmentsPage] = await Promise.all([+ const [mappings, federatedCredentials, roles, environmentsPage] = await Promise.all([oidcMappingService.list(),- roleService.getAll(),- environmentManagementService.getEnvironments({- pagination: { page: 1, limit: 1000 },- sort: { column: 'name', direction: 'asc' }+ queryClient.fetchQuery({+ queryKey: queryKeys.federatedCredentials.list(federatedCredentialRequestOptions),+ queryFn: () => federatedCredentialService.list(federatedCredentialRequestOptions)+ }),+ queryClient.fetchQuery({+ queryKey: ['roles', 'all'],+ queryFn: () => roleService.getAll()+ }),+ queryClient.fetchQuery({+ queryKey: queryKeys.environments.list({+ pagination: { page: 1, limit: 1000 },+ sort: { column: 'name', direction: 'asc' }+ }),+ queryFn: () =>+ environmentManagementService.getEnvironments({+ pagination: { page: 1, limit: 1000 },+ sort: { column: 'name', direction: 'asc' }+ })})]);return {...parentData,+ activeAuthTab,oidcMappings: mappings,+ federatedCredentials,+ federatedCredentialRequestOptions,roles,environments: environmentsPage.data};diff --git a/frontend/src/routes/(app)/settings/authentication/federated-credential-table.svelte b/frontend/src/routes/(app)/settings/authentication/federated-credential-table.sveltenew file mode 100644index 000000000..a7e9fdb9d--- /dev/null+++ b/frontend/src/routes/(app)/settings/authentication/federated-credential-table.svelte@@ -0,0 +1,290 @@+<script lang="ts">+ import ArcaneTable from '$lib/components/arcane-table/arcane-table.svelte';+ import { ArcaneButton } from '$lib/components/arcane-button/index.js';+ import * as DropdownMenu from '$lib/components/ui/dropdown-menu/index.js';+ import StatusBadge from '$lib/components/badges/status-badge.svelte';+ import { toast } from 'svelte-sonner';+ import { openConfirmDialog } from '$lib/components/confirm-dialog';+ import { handleApiResultWithCallbacks } from '$lib/utils/api';+ import { tryCatch } from '$lib/utils/api';+ import type { Paginated, SearchPaginationSortRequest } from '$lib/types/shared';+ import type { FederatedCredential } from '$lib/types/auth';+ import type { ColumnSpec, MobileFieldVisibility, BulkAction } from '$lib/components/arcane-table';+ import { UniversalMobileCard } from '$lib/components/arcane-table';+ import { federatedCredentialService } from '$lib/services/federated-credential-service';+ import * as m from '$lib/paraglide/messages.js';+ import { LockIcon, TrashIcon, EditIcon, EllipsisIcon } from '$lib/icons';+ import { isGlobalAdmin } from '$lib/utils/auth';++ let {+ federatedCredentials = $bindable(),+ selectedIds = $bindable(),+ requestOptions = $bindable(),+ onFederatedCredentialsChanged,+ onEditFederatedCredential+ }: {+ federatedCredentials: Paginated<FederatedCredential>;+ selectedIds: string[];+ requestOptions: SearchPaginationSortRequest;+ onFederatedCredentialsChanged: () => Promise<void>;+ onEditFederatedCredential: (credential: FederatedCredential) => void;+ } = $props();++ let isLoading = $state({+ removing: false+ });+ const canManageFederatedCredentials = $derived(isGlobalAdmin());++ function formatDate(dateString?: string): string {+ if (!dateString) return '-';+ return new Date(dateString).toLocaleString();+ }++ function isExpired(expiresAt?: string): boolean {+ if (!expiresAt) return false;+ return new Date(expiresAt) < new Date();+ }++ function getStatusText(credential: FederatedCredential): string {+ if (isExpired(credential.expiresAt)) return m.federated_credential_status_expired();+ if (!credential.enabled) return m.common_disabled();+ return m.common_enabled();+ }++ function getStatusVariant(credential: FederatedCredential): 'red' | 'green' | 'gray' {+ if (isExpired(credential.expiresAt)) return 'red';+ if (!credential.enabled) return 'gray';+ return 'green';+ }++ function getScope(credential: FederatedCredential): string {+ return credential.environmentName || m.federated_credential_scope_global_option();+ }++ function getRoleScope(credential: FederatedCredential): string {+ const role = credential.roleName || credential.roleId;+ return `${role} / ${getScope(credential)}`;+ }++ async function handleDeleteSelected() {+ if (selectedIds.length === 0) return;++ openConfirmDialog({+ title: m.federated_credential_delete_selected_title({ count: selectedIds.length }),+ message: m.federated_credential_delete_selected_message({ count: selectedIds.length }),+ confirm: {+ label: m.common_delete(),+ destructive: true,+ action: async () => {+ isLoading.removing = true;+ let successCount = 0;+ let failureCount = 0;++ for (const credentialId of selectedIds) {+ const result = await tryCatch(federatedCredentialService.delete(credentialId));+ handleApiResultWithCallbacks({+ result,+ message: m.federated_credential_delete_failed({ name: credentialId }),+ setLoadingState: () => {},+ onSuccess: () => {+ successCount++;+ }+ });++ if (result.error) {+ failureCount++;+ }+ }++ isLoading.removing = false;++ if (successCount > 0) {+ toast.success(m.federated_credential_bulk_delete_success({ count: successCount }));+ await onFederatedCredentialsChanged();+ }++ if (failureCount > 0) {+ toast.error(m.federated_credential_bulk_delete_failed({ count: failureCount }));+ }++ selectedIds = [];+ }+ }+ });+ }++ async function handleDeleteFederatedCredential(credentialId: string, name: string) {+ const safeName = name?.trim() || m.common_unknown();+ openConfirmDialog({+ title: m.federated_credential_delete_title({ name: safeName }),+ message: m.federated_credential_delete_message({ name: safeName }),+ confirm: {+ label: m.common_delete(),+ destructive: true,+ action: async () => {+ isLoading.removing = true;+ handleApiResultWithCallbacks({+ result: await tryCatch(federatedCredentialService.delete(credentialId)),+ message: m.federated_credential_delete_failed({ name: safeName }),+ setLoadingState: (value) => (isLoading.removing = value),+ onSuccess: async () => {+ toast.success(m.federated_credential_delete_success({ name: safeName }));+ await onFederatedCredentialsChanged();+ }+ });+ }+ }+ });+ }++ const columns = [+ { accessorKey: 'name', title: m.common_name(), sortable: true, cell: NameCell },+ { accessorKey: 'issuerUrl', title: m.federated_credential_issuer_label(), sortable: true, cell: IssuerCell },+ { accessorKey: 'subjectMatch', title: m.federated_credential_subject_match_label(), sortable: true, cell: SubjectCell },+ { accessorKey: 'roleId', title: m.federated_credential_role_scope_column(), sortable: false, cell: RoleScopeCell },+ { accessorKey: 'enabled', title: m.common_status(), sortable: true, cell: StatusCell },+ { accessorKey: 'lastUsedAt', title: m.federated_credential_last_used(), sortable: true, cell: LastUsedCell }+ ] satisfies ColumnSpec<FederatedCredential>[];++ const mobileFields = [+ { id: 'issuerUrl', label: m.federated_credential_issuer_label(), defaultVisible: true },+ { id: 'subjectMatch', label: m.federated_credential_subject_match_label(), defaultVisible: true },+ { id: 'roleScope', label: m.federated_credential_role_scope_column(), defaultVisible: true },+ { id: 'lastUsedAt', label: m.federated_credential_last_used(), defaultVisible: true }+ ];++ const bulkActions = $derived.by<BulkAction[]>(() => {+ if (!canManageFederatedCredentials) return [];+ return [+ {+ id: 'remove',+ label: m.common_remove_selected_count({ count: selectedIds?.length ?? 0 }),+ action: 'remove',+ onClick: handleDeleteSelected,+ loading: isLoading.removing,+ disabled: isLoading.removing || selectedIds.length === 0,+ icon: TrashIcon+ }+ ];+ });++ let mobileFieldVisibility = $state<Record<string, boolean>>({});+</script>++{#snippet NameCell({ item }: { item: FederatedCredential })}+ <span class="font-medium">{item.name}</span>+{/snippet}++{#snippet IssuerCell({ item }: { item: FederatedCredential })}+ <span class="text-muted-foreground max-w-[18rem] truncate">{item.issuerUrl}</span>+{/snippet}++{#snippet SubjectCell({ item }: { item: FederatedCredential })}+ <div class="flex flex-col gap-0.5">+ <span class="font-mono text-xs">{item.subjectMatch}</span>+ <span class="text-muted-foreground text-xs">{item.subjectClaim} / {item.matchType}</span>+ </div>+{/snippet}++{#snippet RoleScopeCell({ item }: { item: FederatedCredential })}+ <span>{getRoleScope(item)}</span>+{/snippet}++{#snippet StatusCell({ item }: { item: FederatedCredential })}+ <StatusBadge text={getStatusText(item)} variant={getStatusVariant(item)} />+{/snippet}++{#snippet LastUsedCell({ item }: { item: FederatedCredential })}+ {formatDate(item.lastUsedAt)}+{/snippet}++{#snippet FederatedCredentialMobileCardSnippet({+ item,+ mobileFieldVisibility+}: {+ item: FederatedCredential;+ mobileFieldVisibility: MobileFieldVisibility;+})}+ <UniversalMobileCard+ {item}+ icon={{ component: LockIcon, variant: 'blue' }}+ title={(item: FederatedCredential) => item.name}+ subtitle={(item: FederatedCredential) => ((mobileFieldVisibility['issuerUrl'] ?? true) ? item.issuerUrl : null)}+ badges={[+ (item: FederatedCredential) => ({+ variant: getStatusVariant(item),+ text: getStatusText(item)+ })+ ]}+ fields={[+ {+ label: m.federated_credential_subject_match_label(),+ getValue: (item: FederatedCredential) => item.subjectMatch,+ icon: LockIcon,+ iconVariant: 'gray' as const,+ show: mobileFieldVisibility['subjectMatch'] ?? true+ },+ {+ label: m.federated_credential_role_scope_column(),+ getValue: (item: FederatedCredential) => getRoleScope(item),+ icon: LockIcon,+ iconVariant: 'gray' as const,+ show: mobileFieldVisibility['roleScope'] ?? true+ },+ {+ label: m.federated_credential_last_used(),+ getValue: (item: FederatedCredential) => formatDate(item.lastUsedAt),+ icon: LockIcon,+ iconVariant: 'gray' as const,+ show: mobileFieldVisibility['lastUsedAt'] ?? true+ }+ ]}+ rowActions={RowActions}+ />+{/snippet}++{#snippet RowActions({ item }: { item: FederatedCredential })}+ {#if canManageFederatedCredentials}+ <DropdownMenu.Root>+ <DropdownMenu.Trigger>+ {#snippet child({ props })}+ <ArcaneButton {...props} action="base" tone="ghost" size="icon" class="size-8">+ <span class="sr-only">{m.common_open_menu()}</span>+ <EllipsisIcon class="size-4" />+ </ArcaneButton>+ {/snippet}+ </DropdownMenu.Trigger>+ <DropdownMenu.Content align="end">+ <DropdownMenu.Group>+ <DropdownMenu.Item onclick={() => onEditFederatedCredential(item)}>+ <EditIcon class="size-4" />+ {m.common_edit()}+ </DropdownMenu.Item>+ <DropdownMenu.Separator />+ <DropdownMenu.Item variant="destructive" onclick={() => handleDeleteFederatedCredential(item.id, item.name)}>+ <TrashIcon class="size-4" />+ {m.common_delete()}+ </DropdownMenu.Item>+ </DropdownMenu.Group>+ </DropdownMenu.Content>+ </DropdownMenu.Root>+ {/if}+{/snippet}++<ArcaneTable+ persistKey="arcane-federated-credentials-table"+ items={federatedCredentials}+ bind:requestOptions+ bind:selectedIds+ bind:mobileFieldVisibility+ {bulkActions}+ onRefresh={async (options) => {+ requestOptions = options;+ await onFederatedCredentialsChanged();+ return federatedCredentials;+ }}+ {columns}+ {mobileFields}+ rowActions={RowActions}+ mobileCard={FederatedCredentialMobileCardSnippet}+/>diff --git a/frontend/src/routes/(app)/settings/authentication/federated-credentials-tab.svelte b/frontend/src/routes/(app)/settings/authentication/federated-credentials-tab.sveltenew file mode 100644index 000000000..c88cec2f0--- /dev/null+++ b/frontend/src/routes/(app)/settings/authentication/federated-credentials-tab.svelte@@ -0,0 +1,195 @@+<script lang="ts">+ import { toast } from 'svelte-sonner';+ import { untrack } from 'svelte';+ import { handleApiResultWithCallbacks, tryCatch } from '$lib/utils/api';+ import FederatedCredentialTable from './federated-credential-table.svelte';+ import FederatedCredentialFormSheet from '$lib/components/sheets/federated-credential-form-sheet.svelte';+ import type { Paginated, SearchPaginationSortRequest } from '$lib/types/shared';+ import type { CreateFederatedCredential, FederatedCredential, Role } from '$lib/types/auth';+ import type { Environment } from '$lib/types/environment';+ import { federatedCredentialService } from '$lib/services/federated-credential-service';+ import * as ResponsiveDialog from '$lib/components/ui/responsive-dialog/index.js';+ import { ArcaneButton } from '$lib/components/arcane-button/index.js';+ import { Snippet } from '$lib/components/ui/snippet/index.js';+ import IfPermitted from '$lib/components/if-permitted.svelte';+ import * as m from '$lib/paraglide/messages.js';++ interface Props {+ initialFederatedCredentials: Paginated<FederatedCredential>;+ initialRequestOptions: SearchPaginationSortRequest;+ roles: Role[];+ environments: Environment[];+ }++ let { initialFederatedCredentials, initialRequestOptions, roles, environments }: Props = $props();++ let federatedCredentials = $state(untrack(() => initialFederatedCredentials));+ let selectedIds: string[] = $state([]);+ let requestOptions: SearchPaginationSortRequest = $state(untrack(() => initialRequestOptions));++ let isDialogOpen = $state({+ create: false,+ edit: false,+ instructions: false+ });++ let credentialToEdit: FederatedCredential | null = $state(null);+ let newlyCreatedCredential: FederatedCredential | null = $state(null);++ let isLoading = $state({+ creating: false,+ editing: false+ });++ function openCreateDialog() {+ credentialToEdit = null;+ isDialogOpen.create = true;+ }++ function openEditDialog(credential: FederatedCredential) {+ credentialToEdit = credential;+ isDialogOpen.edit = true;+ }++ async function refreshFederatedCredentials() {+ federatedCredentials = await federatedCredentialService.list(requestOptions);+ }++ async function handleFederatedCredentialSubmit({+ credential,+ isEditMode,+ credentialId+ }: {+ credential: CreateFederatedCredential;+ isEditMode: boolean;+ credentialId?: string;+ }) {+ const loading = isEditMode ? 'editing' : 'creating';+ isLoading[loading] = true;++ try {+ const safeName = credential.name?.trim() || m.common_unknown();+ if (isEditMode && credentialId) {+ const result = await tryCatch(federatedCredentialService.update(credentialId, credential));+ handleApiResultWithCallbacks({+ result,+ message: m.federated_credential_update_failed({ name: safeName }),+ setLoadingState: (value) => (isLoading[loading] = value),+ onSuccess: async () => {+ toast.success(m.federated_credential_updated_success({ name: safeName }));+ await refreshFederatedCredentials();+ isDialogOpen.edit = false;+ credentialToEdit = null;+ }+ });+ } else {+ const result = await tryCatch(federatedCredentialService.create(credential));+ handleApiResultWithCallbacks({+ result,+ message: m.federated_credential_create_failed({ name: safeName }),+ setLoadingState: (value) => (isLoading[loading] = value),+ onSuccess: async (createdCredential) => {+ toast.success(m.federated_credential_created_success({ name: safeName }));+ await refreshFederatedCredentials();+ isDialogOpen.create = false;+ newlyCreatedCredential = createdCredential as FederatedCredential;+ isDialogOpen.instructions = true;+ }+ });+ }+ } catch (error) {+ console.error('Failed to submit federated credential:', error);+ }+ }++ function instructionsSnippet(credential: FederatedCredential | null): string {+ const audience = credential?.audiences?.[0] ?? 'https://arcane.example.com';+ const serverURL = globalThis.location?.origin ?? 'https://arcane.example.com';+ return `permissions: { id-token: write, contents: read }+steps:+ - run: |+ eval "$(arcane-cli auth federated \\+ --server ${serverURL} \\+ --audience ${audience} --export)"+ - run: arcane-cli projects up my-app`;+ }+</script>++<IfPermitted perm="federated:list">+ <div class="space-y-4">+ <div class="flex items-start justify-between gap-4">+ <div>+ <h3 class="text-base font-semibold">{m.federated_credential_page_title()}</h3>+ <p class="text-muted-foreground mt-1 text-sm">{m.federated_credential_page_description()}</p>+ </div>+ <IfPermitted adminOnly>+ <ArcaneButton+ action="create"+ size="sm"+ onclick={openCreateDialog}+ loading={isLoading.creating}+ disabled={isLoading.creating}+ customLabel={m.federated_credential_create_button()}+ />+ </IfPermitted>+ </div>++ <FederatedCredentialTable+ bind:federatedCredentials+ bind:selectedIds+ bind:requestOptions+ onFederatedCredentialsChanged={refreshFederatedCredentials}+ onEditFederatedCredential={openEditDialog}+ />+ </div>++ <FederatedCredentialFormSheet+ bind:open={isDialogOpen.create}+ credentialToEdit={null}+ {roles}+ {environments}+ onSubmit={handleFederatedCredentialSubmit}+ isLoading={isLoading.creating}+ />++ <FederatedCredentialFormSheet+ bind:open={isDialogOpen.edit}+ {credentialToEdit}+ {roles}+ {environments}+ onSubmit={handleFederatedCredentialSubmit}+ isLoading={isLoading.editing}+ />++ <ResponsiveDialog.Root+ bind:open={isDialogOpen.instructions}+ title={m.federated_credential_instructions_title()}+ description={m.federated_credential_instructions_description()}+ contentClass="!max-w-2xl"+ >+ <div class="space-y-4 py-4">+ <div class="bg-muted rounded-lg p-4">+ <p class="text-muted-foreground mb-2 text-sm font-medium">+ {m.federated_credential_instructions_snippet_label()}+ </p>+ <Snippet+ text={instructionsSnippet(newlyCreatedCredential)}+ onCopy={(status) => {+ if (status === 'success') {+ toast.success(m.common_copied());+ }+ }}+ />+ </div>+ </div>+ {#snippet footer()}+ <ArcaneButton action="confirm" onclick={() => (isDialogOpen.instructions = false)} customLabel={m.common_done()} />+ {/snippet}+ </ResponsiveDialog.Root>++ {#snippet fallback()}+ <div class="border-border/40 bg-muted/20 rounded-lg border border-dashed p-6 text-center">+ <p class="text-muted-foreground text-sm">{m.no_access_page_body()}</p>+ </div>+ {/snippet}+</IfPermitted>diff --git a/tests/setup/compose-proxy.yaml b/tests/setup/compose-proxy.yamlindex ed18bf0ec..ab944bcf5 100644--- a/tests/setup/compose-proxy.yaml+++ b/tests/setup/compose-proxy.yaml@@ -33,7 +33,9 @@ services:arcane:image: arcane:playwright-testsports:- - '3002:3552'+ - '${E2E_PROXY_PORT:-3002}:3552'+ extra_hosts:+ - 'host.docker.internal:host-gateway'environment:- ENVIRONMENT=testing- APP_ENV=testdiff --git a/tests/spec/cli.spec.ts b/tests/spec/cli.spec.tsindex 9ff56d79b..46a9d8da2 100644--- a/tests/spec/cli.spec.ts+++ b/tests/spec/cli.spec.ts@@ -1,6 +1,7 @@import { expect, test } from '@playwright/test';import playwrightConfig from '../playwright.config';import { createCLIConfig, runCLI, runCLIJSON, type CLIConfig } from '../utils/cli.util';+import { createMockOidcIssuer } from '../utils/oidc.util';import { createTestApiKeys, deleteTestApiKeys } from '../utils/playwright.util';type CreatedApiKey = {@@ -15,6 +16,28 @@ type PaginatedResponse<T> = {pagination?: { totalItems?: number };};+type Role = {+ id: string;+ name: string;+};++type FederatedCredential = {+ id: string;+};++type PlaywrightFederatedCredentialResponse = {+ credential: FederatedCredential;+};++type FederatedAuthOutput = {+ token: string;+ tokenType: string;+ expiresIn: number;+ issuedTokenType: string;+ source: string;+ persisted: boolean;+};+type JsonSmokeCommand = {name: string;args: string[];@@ -45,6 +68,33 @@ async function runCommandJSON<T>(configPath: string, args: string[]): Promise<T>}}+async function arcaneAPI<T>(path: string, init: RequestInit = {}): Promise<T> {+ const headers = new Headers(init.headers);+ headers.set('X-API-KEY', apiKey);+ if (init.body) {+ headers.set('Content-Type', headers.get('Content-Type') ?? 'application/json');+ }++ const response = await fetch(new URL(path, baseURL), { ...init, headers });+ if (!response.ok) {+ throw new Error(+ `${init.method ?? 'GET'} ${path} failed: ${response.status} ${await response.text()}`+ );+ }++ return (await response.json()) as T;+}++async function deleteFederatedCredential(id: string): Promise<void> {+ const response = await fetch(new URL(`/api/federated-credentials/${id}`, baseURL), {+ method: 'DELETE',+ headers: { 'X-API-KEY': apiKey }+ });+ if (!response.ok && response.status !== 404) {+ throw new Error(`failed to delete federated credential ${id}: ${response.status}`);+ }+}+function expectPaginated(value: unknown): void {expect(value).toEqual(expect.objectContaining({@@ -277,6 +327,84 @@ test.describe('arcane-cli e2e', () => {});});+ test('auth federated exchanges a mock OIDC token and persists the CLI JWT', async () => {+ const issuer = await createMockOidcIssuer();+ const config = await createCLIConfig(baseURL, '');+ const subject = `repo:getarcaneapp/arcane:ref:refs/heads/e2e-${Date.now()}`;+ const audience = 'arcane-cli-e2e';+ let credentialID = '';++ try {+ const roles = await arcaneAPI<PaginatedResponse<Role>>('/api/roles?limit=100');+ const viewerRole = roles.data.find((role) => role.id === 'role_viewer');+ expect(viewerRole).toBeTruthy();++ const created = await arcaneAPI<PlaywrightFederatedCredentialResponse>(+ '/api/playwright/create-test-federated-credential',+ {+ method: 'POST',+ body: JSON.stringify({+ issuerUrl: issuer.issuerURL,+ audiences: [audience],+ subject,+ roleId: viewerRole!.id,+ tokenTtlSeconds: 600+ })+ }+ );+ credentialID = created.credential.id;++ const now = Math.floor(Date.now() / 1000);+ const subjectToken = issuer.token({+ iss: issuer.issuerURL,+ sub: subject,+ aud: audience,+ iat: now - 5,+ nbf: now - 5,+ exp: now + 300,+ jti: `cli-e2e-${now}`+ });++ const exchange = await runCommandJSON<FederatedAuthOutput>(config.configPath, [+ 'auth',+ 'federated',+ '--server',+ baseURL,+ '--audience',+ audience,+ '--token',+ subjectToken,+ '--persist',+ '--json'+ ]);++ expect(exchange).toEqual(+ expect.objectContaining({+ token: expect.any(String),+ tokenType: 'Bearer',+ expiresIn: expect.any(Number),+ source: 'flag',+ persisted: true+ })+ );+ expect(exchange.expiresIn).toBeGreaterThan(0);++ const projects = await runCLIJSON<PaginatedResponse<{ id: string }>>(config.configPath, [+ 'projects',+ 'list',+ '--limit',+ '1'+ ]);+ expect(Array.isArray(projects.data)).toBe(true);+ } finally {+ if (credentialID) {+ await deleteFederatedCredential(credentialID);+ }+ await config.cleanup();+ await issuer.close();+ }+ });+test('environments list and get return local environment JSON', async () => {await withConfig(async (config) => {const environments = await runCLIJSON<PaginatedResponse<{ id: string; name: string }>>(diff --git a/tests/utils/oidc.util.ts b/tests/utils/oidc.util.tsnew file mode 100644index 000000000..eb3648f00--- /dev/null+++ b/tests/utils/oidc.util.ts@@ -0,0 +1,86 @@+import crypto from 'node:crypto';+import http from 'node:http';++type JwtClaims = Record<string, unknown>;++export type MockOidcIssuer = {+ issuerURL: string;+ token: (claims: JwtClaims) => string;+ close: () => Promise<void>;+};++function base64url(value: Buffer | string): string {+ return Buffer.from(value).toString('base64url');+}++function signJWT(privateKey: crypto.KeyObject, keyID: string, claims: JwtClaims): string {+ const header = base64url(JSON.stringify({ alg: 'RS256', kid: keyID, typ: 'JWT' }));+ const payload = base64url(JSON.stringify(claims));+ const input = `${header}.${payload}`;+ const signature = crypto.createSign('RSA-SHA256').update(input).sign(privateKey, 'base64url');++ return `${input}.${signature}`;+}++export async function createMockOidcIssuer(): Promise<MockOidcIssuer> {+ const keyID = `arcane-e2e-${crypto.randomUUID()}`;+ const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {+ modulusLength: 2048+ });+ const publicJWK = publicKey.export({ format: 'jwk' });++ let issuerURL = '';+ const server = http.createServer((req, res) => {+ const path = req.url?.split('?')[0];++ if (path === '/.well-known/openid-configuration') {+ res.writeHead(200, { 'Content-Type': 'application/json' });+ res.end(+ JSON.stringify({+ issuer: issuerURL,+ jwks_uri: `${issuerURL}/jwks`,+ authorization_endpoint: `${issuerURL}/authorize`,+ token_endpoint: `${issuerURL}/token`+ })+ );+ return;+ }++ if (path === '/jwks') {+ res.writeHead(200, { 'Content-Type': 'application/json' });+ res.end(+ JSON.stringify({+ keys: [{ ...publicJWK, kid: keyID, use: 'sig', alg: 'RS256' }]+ })+ );+ return;+ }++ res.writeHead(404);+ res.end();+ });++ await new Promise<void>((resolve, reject) => {+ server.once('error', reject);+ server.listen(0, '0.0.0.0', () => {+ server.off('error', reject);+ resolve();+ });+ });++ const address = server.address();+ if (!address || typeof address === 'string') {+ throw new Error('mock OIDC issuer did not bind to a TCP port');+ }++ issuerURL = `http://host.docker.internal:${address.port}`;++ return {+ issuerURL,+ token: (claims) => signJWT(privateKey, keyID, claims),+ close: () =>+ new Promise<void>((resolve, reject) => {+ server.close((error) => (error ? reject(error) : resolve()));+ })+ };+}diff --git a/types/federated/federated.go b/types/federated/federated.gonew file mode 100644index 000000000..a112a5f46--- /dev/null+++ b/types/federated/federated.go@@ -0,0 +1,93 @@+// Package federated contains DTOs for OIDC workload identity federation.+package federated++import "time"++const (+ TokenExchangeGrantType = "urn:ietf:params:oauth:grant-type:token-exchange" // #nosec G101: RFC 8693 grant type identifier, not a credential.+ SubjectTokenTypeJWT = "urn:ietf:params:oauth:token-type:jwt" // #nosec G101: RFC 8693 token type identifier, not a credential.+ SubjectTokenTypeIDToken = "urn:ietf:params:oauth:token-type:id_token" // #nosec G101: RFC 8693 token type identifier, not a credential.+ IssuedTokenTypeAccessToken = "urn:ietf:params:oauth:token-type:access_token" // #nosec G101: RFC 8693 token type identifier, not a credential.+ RequestedTokenTypeAccessJWT = "urn:ietf:params:oauth:token-type:access_token" // #nosec G101: RFC 8693 token type identifier, not a credential.++ MatchTypeExact = "exact"+ MatchTypeGlob = "glob"+)++// FederatedCredential is a configured trust rule for one external OIDC+// workload identity subject.+type FederatedCredential struct {+ ID string `json:"id" doc:"Unique identifier of the federated credential"`+ Name string `json:"name" doc:"Display name"`+ Description *string `json:"description,omitempty" doc:"Optional description"`+ Enabled bool `json:"enabled" doc:"Whether exchanges are allowed"`+ IssuerURL string `json:"issuerUrl" doc:"Trusted external OIDC issuer URL"`+ Audiences []string `json:"audiences" doc:"Allowed external token audiences"`+ SubjectClaim string `json:"subjectClaim" doc:"Claim path to match against"`+ SubjectMatch string `json:"subjectMatch" doc:"Exact subject or anchored glob pattern"`+ MatchType string `json:"matchType" doc:"Subject match strategy" enum:"exact,glob"`+ RoleID string `json:"roleId" doc:"Mapped role ID"`+ EnvironmentID *string `json:"environmentId,omitempty" doc:"Optional environment scope for the role assignment"`+ IdentityUserID string `json:"identityUserId" doc:"Dedicated service user ID backing issued tokens"`+ TokenTTLSeconds int `json:"tokenTtlSeconds" doc:"Issued token lifetime in seconds"`+ LastUsedAt *time.Time `json:"lastUsedAt,omitempty" doc:"Last successful token exchange"`+ ExpiresAt *time.Time `json:"expiresAt,omitempty" doc:"Optional credential expiration"`+ CreatedAt time.Time `json:"createdAt" doc:"Creation timestamp"`+ UpdatedAt *time.Time `json:"updatedAt,omitempty" doc:"Last update timestamp"`+ ServiceUsername string `json:"serviceUsername,omitempty" doc:"Dedicated service account username"`+ RoleName string `json:"roleName,omitempty" doc:"Mapped role name"`+ EnvironmentName string `json:"environmentName,omitempty" doc:"Mapped environment name when scoped"`+}++// CreateFederatedCredential is the request body for creating a federated+// workload identity credential.+type CreateFederatedCredential struct {+ Name string `json:"name" minLength:"1" maxLength:"255" doc:"Display name"`+ Description *string `json:"description,omitempty" maxLength:"1000" doc:"Optional description"`+ Enabled bool `json:"enabled" doc:"Whether exchanges are allowed"`+ IssuerURL string `json:"issuerUrl" minLength:"1" format:"uri" doc:"Trusted external OIDC issuer URL"`+ Audiences []string `json:"audiences" minItems:"1" doc:"Allowed external token audiences"`+ SubjectClaim string `json:"subjectClaim,omitempty" doc:"Claim path to match against; defaults to sub"`+ SubjectMatch string `json:"subjectMatch" minLength:"1" doc:"Exact subject or anchored glob pattern"`+ MatchType string `json:"matchType,omitempty" enum:"exact,glob" doc:"Subject match strategy"`+ RoleID string `json:"roleId" minLength:"1" doc:"Mapped role ID"`+ EnvironmentID *string `json:"environmentId,omitempty" doc:"Optional environment scope for the role assignment"`+ TokenTTLSeconds int `json:"tokenTtlSeconds,omitempty" minimum:"60" maximum:"3600" doc:"Issued token lifetime in seconds"`+ ExpiresAt *time.Time `json:"expiresAt,omitempty" doc:"Optional credential expiration"`+}++// UpdateFederatedCredential is the request body for updating a federated+// workload identity credential.+type UpdateFederatedCredential struct {+ Name *string `json:"name,omitempty" maxLength:"255" doc:"Display name"`+ Description *string `json:"description,omitempty" maxLength:"1000" doc:"Optional description"`+ Enabled *bool `json:"enabled,omitempty" doc:"Whether exchanges are allowed"`+ IssuerURL *string `json:"issuerUrl,omitempty" format:"uri" doc:"Trusted external OIDC issuer URL"`+ Audiences []string `json:"audiences,omitempty" minItems:"1" doc:"Allowed external token audiences"`+ SubjectClaim *string `json:"subjectClaim,omitempty" doc:"Claim path to match against"`+ SubjectMatch *string `json:"subjectMatch,omitempty" minLength:"1" doc:"Exact subject or anchored glob pattern"`+ MatchType *string `json:"matchType,omitempty" enum:"exact,glob" doc:"Subject match strategy"`+ RoleID *string `json:"roleId,omitempty" minLength:"1" doc:"Mapped role ID"`+ EnvironmentID *string `json:"environmentId,omitempty" doc:"Optional environment scope for the role assignment"`+ TokenTTLSeconds *int `json:"tokenTtlSeconds,omitempty" minimum:"60" maximum:"3600" doc:"Issued token lifetime in seconds"`+ ExpiresAt *time.Time `json:"expiresAt,omitempty" doc:"Optional credential expiration"`+}++// TokenExchangeRequest is the RFC 8693 token exchange form payload after+// server-side parsing.+type TokenExchangeRequest struct {+ GrantType string+ SubjectToken string+ SubjectTokenType string+ Audience string+ Scope string+ RequestedTokenType string+}++// FederatedTokenResponse is the RFC 8693 successful token exchange response.+type FederatedTokenResponse struct {+ AccessToken string `json:"access_token"` //nolint:tagliatelle // RFC 8693 wire shape is snake_case.+ TokenType string `json:"token_type"` //nolint:tagliatelle // RFC 8693 wire shape is snake_case.+ ExpiresIn int `json:"expires_in"` //nolint:tagliatelle // RFC 8693 wire shape is snake_case.+ IssuedTokenType string `json:"issued_token_type"` //nolint:tagliatelle // RFC 8693 wire shape is snake_case.+}