Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: scope environment access tokens to their environment (#3030)
Kyle Mendell88367bc213de
diff --git a/backend/api/middleware/auth.go b/backend/api/middleware/auth.goindex 17aba7ca3..0a8df7726 100644--- a/backend/api/middleware/auth.go+++ b/backend/api/middleware/auth.go@@ -154,17 +154,17 @@ func tryApiKeyAuthInternal(ctx huma.Context, apiKeyService *services.ApiKeyServireturn user, key, true}-func tryEnvironmentAccessTokenAuthInternal(ctx huma.Context, resolver environmentAccessTokenResolver, token string) (*models.User, bool) {+func tryEnvironmentAccessTokenAuthInternal(ctx huma.Context, resolver environmentAccessTokenResolver, token string) (*models.User, *models.Environment, bool) {if resolver == nil || strings.TrimSpace(token) == "" {- return nil, false+ return nil, nil, false}env, err := resolver.ResolveEnvironmentByAccessToken(ctx.Context(), token)if err != nil || env == nil {- return nil, false+ return nil, nil, false}- return createEnvironmentSudoUserInternal(env), true+ return createEnvironmentUserInternal(env), env, true}// tryAgentAuthInternal checks if the request is from an authenticated agent.@@ -207,7 +207,7 @@ func createAgentSudoUserInternal() *models.User {}}-func createEnvironmentSudoUserInternal(env *models.Environment) *models.User {+func createEnvironmentUserInternal(env *models.Environment) *models.User {return &models.User{BaseModel: models.BaseModel{ID: "environment:" + env.ID},Username: env.Name,@@ -238,12 +238,12 @@ func NewAuthBridge(api huma.API, authService *services.AuthService, apiKeyServic}if reqs.apiKeyAuth && ctx.Header(pkgutils.HeaderApiKey) != "" {- handleApiKeyAuthInternal(api, ctx, apiKeyService, permResolver, envTokenResolver, next)+ handleApiKeyAuthInternal(api, ctx, authService, apiKeyService, permResolver, envTokenResolver, reqs.bearerAuth, next)return}- if user, ok := tryEnvironmentAccessTokenAuthInternal(ctx, envTokenResolver, ctx.Header(pkgutils.HeaderAgentToken)); ok {- newCtx := setUserInContextWithSudoInternal(ctx.Context(), user)+ if user, env, ok := tryEnvironmentAccessTokenAuthInternal(ctx, envTokenResolver, ctx.Header(pkgutils.HeaderAgentToken)); ok {+ newCtx := setUserInContextInternal(ctx.Context(), user, authz.EnvironmentPermissionSet(env.ID))next(huma.WithContext(ctx, newCtx))return}@@ -289,9 +289,10 @@ func opportunisticBearerAuthInternal(ctx huma.Context, authService *services.Autreturn huma.WithContext(ctx, newCtx)}-// handleApiKeyAuthInternal handles the API-key-present branch. If validation-// fails, it writes 401 directly — Bearer is not attempted as fallback.-func handleApiKeyAuthInternal(api huma.API, ctx huma.Context, apiKeyService *services.ApiKeyService, permResolver PermissionResolver, envTokenResolver environmentAccessTokenResolver, next func(huma.Context)) {+// handleApiKeyAuthInternal handles the API-key-present branch. Invalid user+// keys fail closed; only recognized environment tokens defer to bearer auth+// when both credentials are present on a bearer-capable operation.+func handleApiKeyAuthInternal(api huma.API, ctx huma.Context, authService *services.AuthService, apiKeyService *services.ApiKeyService, permResolver PermissionResolver, envTokenResolver environmentAccessTokenResolver, allowBearerFallback bool, next func(huma.Context)) {if user, key, ok := tryApiKeyAuthInternal(ctx, apiKeyService); ok {// Personal keys inherit the owner's role permissions (same resolution// as session auth); scoped keys are limited to their own grants.@@ -305,8 +306,17 @@ func handleApiKeyAuthInternal(api huma.API, ctx huma.Context, apiKeyService *sernext(huma.WithContext(ctx, newCtx))return}- if user, ok := tryEnvironmentAccessTokenAuthInternal(ctx, envTokenResolver, ctx.Header(pkgutils.HeaderApiKey)); ok {- newCtx := setUserInContextWithSudoInternal(ctx.Context(), user)+ if user, env, ok := tryEnvironmentAccessTokenAuthInternal(ctx, envTokenResolver, ctx.Header(pkgutils.HeaderApiKey)); ok {+ if allowBearerFallback && extractBearerTokenInternal(ctx) != "" {+ nextCtx, handled := handleBearerAuthInternal(api, ctx, authService, permResolver)+ if handled {+ if nextCtx != nil {+ next(nextCtx)+ }+ return+ }+ }+ newCtx := setUserInContextInternal(ctx.Context(), user, authz.EnvironmentPermissionSet(env.ID))next(huma.WithContext(ctx, newCtx))return}@@ -412,8 +422,8 @@ func setUserInContextInternal(ctx context.Context, user *models.User, ps *authz.}// setUserInContextWithSudoInternal attaches a sudo PermissionSet (bypasses-// every check) plus the user. Used by the agent token and environment-// access token paths, which are infrastructure-level and not per-user.+// every check) plus the user. Used by the agent token path, which is+// infrastructure-level and not per-user.func setUserInContextWithSudoInternal(ctx context.Context, user *models.User) context.Context {return setUserInContextInternal(ctx, user, authz.SudoPermissionSet())}diff --git a/backend/api/middleware/auth_test.go b/backend/api/middleware/auth_test.goindex b54e67107..682c715a1 100644--- a/backend/api/middleware/auth_test.go+++ b/backend/api/middleware/auth_test.go@@ -13,6 +13,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/database""github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/backend/v2/internal/services"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/authz""github.com/getarcaneapp/arcane/types/v2/auth"glsqlite "github.com/glebarez/sqlite""github.com/golang-jwt/jwt/v5"@@ -40,6 +41,45 @@ func (r testEnvironmentAccessResolver) ResolveEnvironmentByAccessToken(_ contextreturn nil, context.Canceled}+type staticPermissionResolverInternal struct {+ ps *authz.PermissionSet+}++func (r staticPermissionResolverInternal) ResolvePermissions(_ context.Context, _ *models.User) (*authz.PermissionSet, error) {+ return r.ps, nil+}++func (r staticPermissionResolverInternal) ResolveApiKeyPermissions(_ context.Context, _ string) (*authz.PermissionSet, error) {+ return r.ps, nil+}++func mintAuthBridgeTestTokenInternal(t *testing.T, userSvc *services.UserService, sessionSvc *services.SessionService, jwtSecret string, userID string) string {+ t.Helper()++ _, err := userSvc.CreateUser(context.Background(), &models.User{+ BaseModel: models.BaseModel{ID: userID},+ Username: userID,+ })+ require.NoError(t, err)++ exp := time.Now().Add(5 * time.Minute)+ session, _, err := sessionSvc.CreateSession(context.Background(), userID, exp, auth.SessionMeta{})+ require.NoError(t, err)++ claims := jwt.MapClaims{+ "jti": userID,+ "sub": "access",+ "iat": time.Now().Unix(),+ "exp": exp.Unix(),+ "sid": session.ID,+ "user_id": userID,+ "username": userID,+ }+ token, err := jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString([]byte(jwtSecret))+ require.NoError(t, err)+ return token+}+func TestNewAuthBridge_AcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {token := "env-access-token"router := echo.New()@@ -74,6 +114,13 @@ func TestNewAuthBridge_AcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {require.Equal(t, "environment:env-self", user.ID)require.Equal(t, "Self Target", user.Username)+ ps, ok := PermissionsFromContext(ctx)+ require.True(t, ok)+ require.True(t, ps.Allows(authz.PermContainersStart, "env-self"))+ require.False(t, ps.Allows(authz.PermContainersStart, "env-other"))+ require.False(t, ps.Allows(authz.PermUsersList, ""))+ require.False(t, ps.IsGlobalAdmin())+resp := &secureOutput{}resp.Body.UserID = user.IDreturn resp, nil@@ -89,6 +136,71 @@ func TestNewAuthBridge_AcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {require.Contains(t, rec.Body.String(), "environment:env-self")}+func TestNewAuthBridge_UsesBearerWhenLoopbackProxySendsEnvironmentAccessToken(t *testing.T) {+ db := setupAuthMiddlewareTestDBInternal(t)+ userSvc := services.NewUserService(db)+ sessionSvc := services.NewSessionService(db)++ jwtSecret := "test-secret-please-do-not-use-in-prod"+ authSvc := services.NewAuthService(userSvc, nil, nil, sessionSvc, nil, jwtSecret, &config.Config{JWTRefreshExpiry: 24 * time.Hour})+ bearerToken := mintAuthBridgeTestTokenInternal(t, userSvc, sessionSvc, jwtSecret, "u-loopback")++ ps := authz.NewPermissionSet()+ ps.AddEnv("0", authz.PermContainersStart)++ envToken := "remote-env-access-token"+ router := echo.New()+ apiGroup := router.Group("/api")++ humaConfig := huma.DefaultConfig("test", "1.0.0")+ humaConfig.Components.SecuritySchemes = map[string]*huma.SecurityScheme{+ "BearerAuth": {Type: "http", Scheme: "bearer"},+ "ApiKeyAuth": {Type: "apiKey", In: "header", Name: "X-API-Key"},+ }++ api := humaecho.NewWithGroup(router, apiGroup, humaConfig)+ api.UseMiddleware(NewAuthBridge(api, authSvc, nil, staticPermissionResolverInternal{ps: ps}, testEnvironmentAccessResolver{+ env: &models.Environment{+ BaseModel: models.BaseModel{ID: "remote-env"},+ Name: "Remote Env",+ AccessToken: &envToken,+ },+ }, &config.Config{}))++ huma.Register(api, huma.Operation{+ OperationID: "loopback-start",+ Method: http.MethodPost,+ Path: "/environments/{id}/containers/{cid}/start",+ Security: []map[string][]string{+ {"BearerAuth": {}},+ {"ApiKeyAuth": {}},+ },+ Middlewares: RequirePermission(api, authz.PermContainersStart),+ }, func(ctx context.Context, _ *struct {+ ID string `path:"id"`+ CID string `path:"cid"`+ }) (*secureOutput, error) {+ user, ok := GetCurrentUserFromContext(ctx)+ require.True(t, ok)+ require.Equal(t, "u-loopback", user.ID)++ resp := &secureOutput{}+ resp.Body.UserID = user.ID+ return resp, nil+ })++ req := httptest.NewRequest(http.MethodPost, "/api/environments/0/containers/c/start", nil)+ req.Header.Set("Authorization", "Bearer "+bearerToken)+ req.Header.Set("X-API-Key", envToken)+ req.Header.Set("X-Arcane-Agent-Token", envToken)+ rec := httptest.NewRecorder()++ router.ServeHTTP(rec, req)++ require.Equal(t, http.StatusOK, rec.Code)+ require.Contains(t, rec.Body.String(), "u-loopback")+}+// A valid API key presented to a BearerAuth-only operation must be rejected:// the bridge only attempts API-key auth when the operation declares ApiKeyAuth.// This is the gate that makes personal-key create/delete session-only.diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.goindex 7b6bc86c6..8ef477982 100644--- a/backend/internal/bootstrap/router_bootstrap.go+++ b/backend/internal/bootstrap/router_bootstrap.go@@ -120,8 +120,8 @@ func createAuthValidatorInternal(appServices *di.Services) middleware.AuthValida}// Environment bootstrap key (user_id = NULL): used by the proxy when forwarding// requests to a remote env whose apiUrl resolves back to this manager.- if _, err := appServices.ApiKey.GetEnvironmentByApiKey(ctx, apiKey); err == nil {- return authz.SudoPermissionSet(), true+ if envID, err := appServices.ApiKey.GetEnvironmentByApiKey(ctx, apiKey); err == nil && envID != nil {+ return authz.EnvironmentPermissionSet(*envID), true}return nil, false}diff --git a/backend/internal/middleware/auth_middleware.go b/backend/internal/middleware/auth_middleware.goindex 2121c0c27..2a67e90cd 100644--- a/backend/internal/middleware/auth_middleware.go+++ b/backend/internal/middleware/auth_middleware.go@@ -180,7 +180,7 @@ func (m *AuthMiddleware) managerAuth(ctx context.Context, c echo.Context, next ereq := c.Request()if agentToken := req.Header.Get(pkgutils.HeaderAgentToken); agentToken != "" {if env, ok := m.resolveEnvironmentAccessToken(ctx, agentToken); ok {- environmentSudoInternal(c, env)+ environmentScopedInternal(c, env)return next(c)}}@@ -273,7 +273,7 @@ func (m *AuthMiddleware) apiKeyHeaderAuth(ctx context.Context, c echo.Context, n}}if env, ok := m.resolveEnvironmentAccessToken(ctx, apiKey); ok {- environmentSudoInternal(c, env)+ environmentScopedInternal(c, env)return next(c)}return c.JSON(http.StatusUnauthorized, models.APIError{@@ -341,14 +341,14 @@ func agentSudoInternal(c echo.Context) {c.Set(echoCtxKeyAuthMethod, "agent_token")}-func environmentSudoInternal(c echo.Context, env *models.Environment) {+func environmentScopedInternal(c echo.Context, env *models.Environment) {envUser := &models.User{BaseModel: models.BaseModel{ID: "environment:" + env.ID},Username: env.Name,}c.Set(echoCtxKeyUserID, envUser.ID)c.Set(echoCtxKeyCurrentUser, envUser)- c.Set(echoCtxKeyUserPermissions, authz.SudoPermissionSet())+ c.Set(echoCtxKeyUserPermissions, authz.EnvironmentPermissionSet(env.ID))c.Set(echoCtxKeyAuthMethod, "environment_access_token")}diff --git a/backend/internal/middleware/auth_middleware_test.go b/backend/internal/middleware/auth_middleware_test.goindex 313d2e0c5..be4d91c0d 100644--- a/backend/internal/middleware/auth_middleware_test.go+++ b/backend/internal/middleware/auth_middleware_test.go@@ -122,6 +122,13 @@ func TestAuthMiddleware_ManagerAuthAcceptsEnvironmentAccessTokenViaAPIKey(t *tesrequire.Equal(t, "Self Target", user.Username)require.Equal(t, "environment_access_token", c.Get("authMethod"))+ ps, ok := c.Get("userPermissions").(*authz.PermissionSet)+ require.True(t, ok)+ require.True(t, ps.Allows(authz.PermContainersStart, "env-self"))+ require.False(t, ps.Allows(authz.PermContainersStart, "env-other"))+ require.False(t, ps.Allows(authz.PermUsersList, ""))+ require.False(t, ps.IsGlobalAdmin())+return c.JSON(http.StatusOK, map[string]any{"userId": user.ID})})diff --git a/backend/internal/middleware/environment_middleware.go b/backend/internal/middleware/environment_middleware.goindex f4ae3111a..5a22c3289 100644--- a/backend/internal/middleware/environment_middleware.go+++ b/backend/internal/middleware/environment_middleware.go@@ -51,8 +51,8 @@ type EnvResolver func(ctx context.Context, id string) (string, *string, bool, er// AuthValidator validates authentication for a request and resolves the// caller's effective permission set. The boolean result reports whether the// request is authenticated; the permission set is used to authorize proxied-// requests against the target environment. Sudo permission sets (environment-// access tokens, internal agent proxies) bypass authorization.+// requests against the target environment. Sudo permission sets (internal+// agent proxies) bypass authorization.type AuthValidator func(ctx context.Context, c echo.Context) (*authz.PermissionSet, bool)// EnvironmentMiddleware proxies requests for remote environments to their respective agents.@@ -181,10 +181,9 @@ func (m *EnvironmentMiddleware) Handle(c echo.Context, next echo.HandlerFunc) er// required for the (method, path) is looked up in the matcher and evaluated// against the caller's permission set for the target environment.//-// Sudo callers (environment access tokens and internal agent proxies) bypass-// the check. Requests whose (method, path) has no known permission mapping are-// denied (default-deny), so a newly added proxied route cannot silently bypass-// authorization before it is mapped.+// Sudo callers bypass the check. Requests whose (method, path) has no known+// permission mapping are denied (default-deny), so a newly added proxied route+// cannot silently bypass authorization before it is mapped.func (m *EnvironmentMiddleware) proxyPermissionDenied(c echo.Context, ps *authz.PermissionSet, envID string) bool {if m.matcher == nil {return falsediff --git a/backend/pkg/authz/permission_set.go b/backend/pkg/authz/permission_set.goindex 66499dd6f..466b60982 100644--- a/backend/pkg/authz/permission_set.go+++ b/backend/pkg/authz/permission_set.go@@ -7,8 +7,7 @@ import "strings"//// Global permissions apply to every environment and to org-level endpoints.// PerEnv permissions apply only when the caller is acting on that specific-// environment. Sudo bypasses all checks (used for the agent token and the-// per-environment access token paths).+// environment. Sudo bypasses all checks (used for the agent token path).type PermissionSet struct {Global map[string]struct{}PerEnv map[string]map[string]struct{}@@ -67,12 +66,27 @@ func (ps *PermissionSet) IsGlobalAdmin() bool {}// SudoPermissionSet returns a PermissionSet that allows every action. Used for-// the agent token and environment access token paths, which bypass per-user-// permission resolution entirely.+// the agent token path, which bypasses per-user permission resolution entirely.func SudoPermissionSet() *PermissionSet {return &PermissionSet{Sudo: true}}+// EnvironmentPermissionSet returns the effective permission set for a+// per-environment access token. It grants every environment-scoped permission+// only for envID and no global or sudo permissions.+func EnvironmentPermissionSet(envID string) *PermissionSet {+ ps := NewPermissionSet()+ if envID == "" {+ return ps+ }+ for _, p := range AllPermissions() {+ if IsEnvScoped(p) {+ ps.AddEnv(envID, p)+ }+ }+ return ps+}+// NewPermissionSet builds an empty PermissionSet ready for population.func NewPermissionSet() *PermissionSet {return &PermissionSet{diff --git a/backend/pkg/authz/permission_set_test.go b/backend/pkg/authz/permission_set_test.goindex 202cecae0..dc7626635 100644--- a/backend/pkg/authz/permission_set_test.go+++ b/backend/pkg/authz/permission_set_test.go@@ -85,6 +85,28 @@ func TestSudoAllowsEverything(t *testing.T) {}}+func TestEnvironmentPermissionSetScopesToOwnEnvironment(t *testing.T) {+ ps := EnvironmentPermissionSet("env-A")++ if !ps.Allows(PermContainersStart, "env-A") {+ t.Fatal("environment token should allow env-scoped permissions for its own env")+ }+ if ps.Allows(PermContainersStart, "env-B") {+ t.Fatal("environment token must not allow env-scoped permissions for another env")+ }+ if ps.Allows(PermUsersList, "") {+ t.Fatal("environment token must not allow org-level permissions")+ }+ if ps.IsGlobalAdmin() {+ t.Fatal("environment token must not be global admin")+ }++ empty := EnvironmentPermissionSet("")+ if empty.Allows(PermContainersStart, "env-A") {+ t.Fatal("environment token with empty env id must deny env-scoped permissions")+ }+}+func TestEnvIDFromPath(t *testing.T) {cases := map[string]string{"/environments/abc-123/containers": "abc-123",