Skip to content

Modern Docker Management, Designed for Everyone

feat: support for federated credentials for workflow automation (#2769)

Kyle Mendell818d30682388
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 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.go
index 131fbdc84..0be9a4a0d 100644
--- a/backend/api/api.go
+++ b/backend/api/api.go
@@ -144,6 +144,7 @@ type Services struct {
Auth *services.AuthService
Oidc *services.OidcService
ApiKey *services.ApiKeyService
+ Federated *services.FederatedCredentialService
AppImages *services.ApplicationImagesService
Project *services.ProjectService
Event *services.EventService
@@ -317,6 +318,7 @@ func registerHandlers(api huma.API, svc *Services) {
var authSvc *services.AuthService
var oidcSvc *services.OidcService
var apiKeySvc *services.ApiKeyService
+ var federatedSvc *services.FederatedCredentialService
var appImagesSvc *services.ApplicationImagesService
var projectSvc *services.ProjectService
var eventSvc *services.EventService
@@ -358,6 +360,7 @@ func registerHandlers(api huma.API, svc *Services) {
authSvc = svc.Auth
oidcSvc = svc.Oidc
apiKeySvc = svc.ApiKey
+ federatedSvc = svc.Federated
appImagesSvc = svc.AppImages
projectSvc = svc.Project
eventSvc = 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.go
new file mode 100644
index 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.go
index ee2f0b828..b1780fd6f 100644
--- a/backend/api/playwright.go
+++ b/backend/api/playwright.go
@@ -24,12 +24,21 @@ func SetupPlaywrightRoutes(api *echo.Group, playwrightService *services.Playwrig
playwright.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 CreateTestApiKeysRequest
if 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.go
index 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")
return
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index 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.go
index 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.VersionService
Notification *services.NotificationService
ApiKey *services.ApiKeyService
+ Federated *services.FederatedCredentialService
GitRepository *services.GitRepositoryService
GitOpsSync *services.GitOpsSyncService
Webhook *services.WebhookService
@@ -104,6 +105,7 @@ func initializeServices(ctx context.Context, db *database.DB, cfg *config.Config
svcs.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.go
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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 tokens
OidcAccessToken *string `json:"-" gorm:"type:text"`
diff --git a/backend/internal/models/user_session.go b/backend/internal/models/user_session.go
index 3b6d155d7..086248baa 100644
--- a/backend/internal/models/user_session.go
+++ b/backend/internal/models/user_session.go
@@ -2,16 +2,25 @@ package models
import "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.go
index 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 ErrInvalidToken
diff --git a/backend/internal/services/event_service.go b/backend/internal/services/event_service.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.go
index 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 int64
if 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, exclud
func (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.PermissionS
if 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.PermissionS
return 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.go
index 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, expir
RefreshTokenHash: 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, expir
return 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, ErrInvalidToken
diff --git a/backend/internal/services/user_service.go b/backend/internal/services/user_service.go
index 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, password
func (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.go
index 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.go
index 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.sql
new file mode 100644
index 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.sql
new file mode 100644
index 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.sql
new file mode 100644
index 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.sql
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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, err
diff --git a/cli/internal/config/config.go b/cli/internal/config/config.go
index 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.go
index 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 use
DefaultEnvironment 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.go
index 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
// OIDC
OIDCDeviceCodeEndpoint string
@@ -178,10 +179,11 @@ var Endpoints = ArcaneApiEndpoints{ //nolint:gosec // static endpoint paths; aut
VersionEndpoint: "/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",
// OIDC
OIDCDeviceCodeEndpoint: "/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 endpoints
func (e ArcaneApiEndpoints) OIDCDeviceCode() string { return e.OIDCDeviceCodeEndpoint }
diff --git a/cli/pkg/auth/federated.go b/cli/pkg/auth/federated.go
new file mode 100644
index 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.go
index 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 = setLogLevel
fmt.Printf("Set log_level = %s\n", setLogLevel)
@@ -431,6 +440,10 @@ func applyConfigSetArg(cfg *clitypes.Config, key, value string) (bool, error) {
cfg.DefaultEnvironment = value
fmt.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, nil
case "log-level", "loglevel", "log_level":
cfg.LogLevel = value
fmt.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.json
index 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.svelte
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.svelte
index 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.ts
index 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.svelte
new file mode 100644
index 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.svelte
new file mode 100644
index 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.yaml
index ed18bf0ec..ab944bcf5 100644
--- a/tests/setup/compose-proxy.yaml
+++ b/tests/setup/compose-proxy.yaml
@@ -33,7 +33,9 @@ services:
arcane:
image: arcane:playwright-tests
ports:
- - '3002:3552'
+ - '${E2E_PROXY_PORT:-3002}:3552'
+ extra_hosts:
+ - 'host.docker.internal:host-gateway'
environment:
- ENVIRONMENT=testing
- APP_ENV=test
diff --git a/tests/spec/cli.spec.ts b/tests/spec/cli.spec.ts
index 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.ts
new file mode 100644
index 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.go
new file mode 100644
index 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.
+}