Skip to content

Modern Docker Management, Designed for Everyone

fix: scope environment access tokens to their environment (#3030)

Kyle Mendell88367bc213de
diff --git a/backend/api/middleware/auth.go b/backend/api/middleware/auth.go
index 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.ApiKeyServi
return 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.Aut
return 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 *ser
next(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.go
index 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(_ context
return 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.ID
return 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.go
index 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.go
index 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 e
req := 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.go
index 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 *tes
require.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.go
index 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 false
diff --git a/backend/pkg/authz/permission_set.go b/backend/pkg/authz/permission_set.go
index 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.go
index 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",