Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package auth
import (
"bytes"
"context"
"crypto/mldsa"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/danielgtaylor/huma/v2"
"github.com/danielgtaylor/huma/v2/adapters/humaecho"
"github.com/getarcaneapp/arcane/types/v2/auth"
"github.com/labstack/echo/v5"
"github.com/lestrrat-go/jwx/v4/jwa"
"github.com/lestrrat-go/jwx/v4/jwt"
"github.com/libtnb/sqlite"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/apikey"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/middleware"
"github.com/getarcaneapp/arcane/backend/v2/internal/session"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/user"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cookie"
)
type secureInput struct{}
type secureOutput struct {
Body struct {
UserID string `json:"userId"`
} `json:"body"`
}
type testEnvironmentAccessResolver struct {
env *environment.Environment
}
func TestNewHumaMiddleware_AcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {
token := "env-access-token"
router := echo.New()
apiGroup := router.Group("/api")
humaConfig := huma.DefaultConfig("test", "1.0.0")
humaConfig.Components.SecuritySchemes = map[string]*huma.SecurityScheme{
"ApiKeyAuth": {
Type: "apiKey",
In: "header",
Name: "X-API-Key",
},
}
api := humaecho.NewWithGroup(router, apiGroup, humaConfig)
api.UseMiddleware(NewHumaMiddleware(api, &AuthService{}, nil, nil, testEnvironmentAccessResolver{
env: &environment.Environment{
ID: "env-self",
Name: "Self Target",
AccessToken: &token,
},
}, &config.Config{}))
huma.Register(api, huma.Operation{
OperationID: "secure",
Method: http.MethodGet,
Path: "/secure",
Security: []map[string][]string{{"ApiKeyAuth": {}}},
}, func(ctx context.Context, _ *secureInput) (*secureOutput, error) {
localUser, ok := user.CurrentUserFromContext(ctx)
require.True(t, ok)
require.Equal(t, "environment:env-self", localUser.ID)
require.Equal(t, "Self Target", localUser.Username)
ps, ok := middleware.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 = localUser.ID
return resp, nil
})
req := httptest.NewRequest(http.MethodGet, "/api/secure", http.NoBody)
req.Header.Set("X-API-Key", token)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
require.Contains(t, rec.Body.String(), "environment:env-self")
}
func TestNewHumaMiddleware_UsesBearerWhenLoopbackProxySendsEnvironmentAccessToken(t *testing.T) {
db := setupAuthMiddlewareTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
sessionSvc := session.NewSessionService(db)
signingKey := newTestSigningKey()
authSvc := NewAuthService(userSvc, nil, nil, sessionSvc, nil, &config.Config{JWTRefreshExpiry: 24 * time.Hour}).WithSigningKey(signingKey)
bearerToken := mintHumaMiddlewareTestToken(t, userSvc, sessionSvc, signingKey, "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(NewHumaMiddleware(api, authSvc, nil, staticPermissionResolver{ps: ps}, testEnvironmentAccessResolver{
env: &environment.Environment{
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: middleware.RequirePermission(api, authz.PermContainersStart),
}, func(ctx context.Context, _ *struct {
ID string `path:"id"`
CID string `path:"cid"`
},
) (*secureOutput, error) {
localUser, ok := user.CurrentUserFromContext(ctx)
require.True(t, ok)
require.Equal(t, "u-loopback", localUser.ID)
resp := &secureOutput{}
resp.Body.UserID = localUser.ID
return resp, nil
})
req := httptest.NewRequest(http.MethodPost, "/api/environments/0/containers/c/start", http.NoBody)
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.
func TestNewHumaMiddleware_RejectsApiKeyOnBearerOnlyOperation(t *testing.T) {
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(NewHumaMiddleware(api, &AuthService{}, nil, nil, nil, &config.Config{}))
huma.Register(api, huma.Operation{
OperationID: "bearer-only",
Method: http.MethodPost,
Path: "/bearer-only",
Security: []map[string][]string{{"BearerAuth": {}}},
}, func(ctx context.Context, _ *secureInput) (*secureOutput, error) {
require.FailNow(t, "handler must not be reached with API key auth")
return &secureOutput{}, nil
})
req := httptest.NewRequest(http.MethodPost, "/api/bearer-only", http.NoBody)
req.Header.Set("X-API-Key", "arc_whatever-valid-or-not-never-consulted")
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusUnauthorized, rec.Code)
}
func TestParseSecurityRequirements(t *testing.T) {
router := echo.New()
apiGroup := router.Group("/api")
humaConfig := huma.DefaultConfig("test", "1.0.0")
humaConfig.Security = []map[string][]string{
{"BearerAuth": {}},
{"ApiKeyAuth": {}},
}
api := humaecho.NewWithGroup(router, apiGroup, humaConfig)
testCases := []struct {
name string
security []map[string][]string
expected securityRequirements
}{
{
name: "nil operation security inherits top-level auth",
security: nil,
expected: securityRequirements{
isRequired: true,
bearerAuth: true,
apiKeyAuth: true,
},
},
{
name: "explicit empty security stays public",
security: []map[string][]string{},
expected: securityRequirements{},
},
{
name: "explicit dual auth stays protected",
security: []map[string][]string{
{"BearerAuth": {}},
{"ApiKeyAuth": {}},
},
expected: securityRequirements{
isRequired: true,
bearerAuth: true,
apiKeyAuth: true,
},
},
{
name: "explicit api key auth stays api-key-only",
security: []map[string][]string{
{"ApiKeyAuth": {}},
},
expected: securityRequirements{
isRequired: true,
apiKeyAuth: true,
},
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
require.Equal(t, testCase.expected, parseSecurityRequirements(api, testOperationProvider{
operation: &huma.Operation{Security: testCase.security},
}))
})
}
}
func TestNewHumaMiddleware_OpportunisticAuthOnPublicRoute(t *testing.T) {
db := setupAuthMiddlewareTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
sessionSvc := session.NewSessionService(db)
signingKey := newTestSigningKey()
cfg := &config.Config{JWTRefreshExpiry: 24 * time.Hour}
authSvc := NewAuthService(userSvc, nil, nil, sessionSvc, nil, cfg).WithSigningKey(signingKey)
_, err := userSvc.CreateUser(t.Context(), &user.User{
ID: "u-logout",
Username: "logouttest",
})
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _, err := sessionSvc.CreateSession(t.Context(), "u-logout", exp, auth.SessionMeta{})
require.NoError(t, err)
claims := map[string]any{
"jti": "u-logout",
"sub": "access",
"iat": time.Now().Unix(),
"exp": exp.Unix(),
"sid": localSession.ID,
"user_id": "u-logout",
"username": "logouttest",
"roles": []string{"user"},
}
token := signJWXToken(t, signingKey, claims)
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"},
}
api := humaecho.NewWithGroup(router, apiGroup, humaConfig)
api.UseMiddleware(NewHumaMiddleware(api, authSvc, nil, nil, nil, &config.Config{}))
var sawSessionID string
huma.Register(api, huma.Operation{
OperationID: "public-with-session",
Method: http.MethodPost,
Path: "/public",
Security: []map[string][]string{},
}, func(ctx context.Context, _ *secureInput) (*secureOutput, error) {
if sid, ok := middleware.GetCurrentSessionIDFromContext(ctx); ok {
sawSessionID = sid
}
return &secureOutput{}, nil
})
t.Run("populates session ID when valid token presented", func(t *testing.T) {
sawSessionID = ""
req := httptest.NewRequest(http.MethodPost, "/api/public", http.NoBody)
req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: token})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
require.Equal(t, localSession.ID, sawSessionID)
})
t.Run("succeeds with no token", func(t *testing.T) {
sawSessionID = ""
req := httptest.NewRequest(http.MethodPost, "/api/public", http.NoBody)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
require.Empty(t, sawSessionID)
})
t.Run("succeeds with invalid token (does not block)", func(t *testing.T) {
sawSessionID = ""
req := httptest.NewRequest(http.MethodPost, "/api/public", http.NoBody)
req.Header.Set("Authorization", "Bearer not-a-valid-token")
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
require.Empty(t, sawSessionID)
})
}
// After a self-update the app version changes and old access tokens fail the version
// check. That must be RECOVERABLE (the refresh path rotates the token), so the
// middleware returns a refreshable 401 and must NOT clear the auth cookies — otherwise
// the user is logged out on every update.
func TestNewHumaMiddleware_VersionMismatchIsRecoverable(t *testing.T) {
db := setupAuthMiddlewareTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
sessionSvc := session.NewSessionService(db)
signingKey := newTestSigningKey()
browserSigningKey := bytes.Repeat([]byte{0x24}, browserSessionSigningKeySize)
cfg := &config.Config{JWTRefreshExpiry: 24 * time.Hour}
authSvc := NewAuthService(userSvc, nil, nil, sessionSvc, nil, cfg).WithSigningKey(signingKey)
authSvc.browserSigningKey = browserSigningKey
_, err := userSvc.CreateUser(t.Context(), &user.User{
ID: "u-ver",
Username: "vertest",
})
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _, err := sessionSvc.CreateSession(t.Context(), "u-ver", exp, auth.SessionMeta{})
require.NoError(t, err)
// An empty appVersion omits the claim, which passes the version check (no pin).
mintToken := func(appVersion string) string {
builder := jwt.NewBuilder().
JwtID("browser-"+appVersion).
Subject(browserTokenSubject).
IssuedAt(time.Now()).
Expiration(exp).
Claim(claimSessionID, localSession.ID).
Claim(claimUserID, "u-ver")
if appVersion != "" {
builder.Claim(claimAppVersion, appVersion)
}
token, buildErr := builder.Build()
require.NoError(t, buildErr)
signed, buildErr := jwt.Sign(token, jwt.WithKey(jwa.HS512(), browserSigningKey))
require.NoError(t, buildErr)
return string(signed)
}
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"},
}
api := humaecho.NewWithGroup(router, apiGroup, humaConfig)
api.UseMiddleware(NewHumaMiddleware(api, authSvc, nil, nil, nil, &config.Config{}))
huma.Register(api, huma.Operation{
OperationID: "protected",
Method: http.MethodGet,
Path: "/protected",
Security: []map[string][]string{{"BearerAuth": {}}},
}, func(_ context.Context, _ *secureInput) (*secureOutput, error) {
return &secureOutput{}, nil
})
t.Run("version mismatch returns a recoverable 401 without clearing cookies", func(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/protected", http.NoBody)
req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: mintToken("v0.0.0-stale")})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusUnauthorized, rec.Code)
require.Contains(t, rec.Body.String(), "Application has been updated")
// The frontend recovers via refresh; clearing the cookies here would log the
// user out on every self-update.
require.Empty(t, rec.Header().Values("Set-Cookie"))
})
t.Run("token without a version pin still authenticates", func(t *testing.T) {
token := mintToken("")
req := httptest.NewRequest(http.MethodGet, "/api/protected", http.NoBody)
req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: token})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
req = httptest.NewRequest(http.MethodGet, "/api/protected", http.NoBody)
req.Header.Set("Authorization", "Bearer "+token)
rec = httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusUnauthorized, rec.Code)
})
}
func TestNewHumaMiddleware_AgentAuthAppliesForwardedIconCatalog(t *testing.T) {
const agentToken = "agent-token"
router := echo.New()
apiGroup := router.Group("/api")
humaConfig := huma.DefaultConfig("test", "1.0.0")
humaConfig.Components.SecuritySchemes = map[string]*huma.SecurityScheme{
"ApiKeyAuth": {Type: "apiKey", In: "header", Name: "X-API-Key"},
}
api := humaecho.NewWithGroup(router, apiGroup, humaConfig)
api.UseMiddleware(NewHumaMiddleware(api, &AuthService{}, nil, nil, nil, &config.Config{
AgentMode: true,
AgentToken: agentToken,
}))
huma.Register(api, huma.Operation{
OperationID: "secure-agent-icon-catalog",
Method: http.MethodGet,
Path: "/secure-agent-icon-catalog",
Security: []map[string][]string{{"ApiKeyAuth": {}}},
}, func(ctx context.Context, _ *secureInput) (*secureOutput, error) {
localUser, ok := user.CurrentUserFromContext(ctx)
require.True(t, ok)
require.NotNil(t, localUser.Preferences.IconCatalog)
require.Equal(t, "dashboard-icons", *localUser.Preferences.IconCatalog)
resp := &secureOutput{}
resp.Body.UserID = localUser.ID
return resp, nil
})
req := httptest.NewRequest(http.MethodGet, "/api/secure-agent-icon-catalog", http.NoBody)
req.Header.Set(middleware.HeaderAgentToken, agentToken)
req.Header.Set(middleware.HeaderIconCatalog, "dashboard-icons")
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
}
func (r testEnvironmentAccessResolver) ResolveEnvironmentByAccessToken(_ context.Context, token string) (*environment.Environment, error) {
if r.env != nil && r.env.AccessToken != nil && *r.env.AccessToken == token {
return r.env, nil
}
return nil, context.Canceled
}
func setupAuthMiddlewareTestDB(t *testing.T) *database.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
require.NoError(t, db.AutoMigrate(&settings.SettingVariable{}, &user.User{}, &session.UserSession{}))
return &database.DB{DB: db}
}
func mintHumaMiddlewareTestToken(t *testing.T, userSvc *user.UserService, sessionSvc *session.SessionService, signingKey *mldsa.PrivateKey, userID string) string {
t.Helper()
_, err := userSvc.CreateUser(t.Context(), &user.User{
ID: userID,
Username: userID,
})
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _, err := sessionSvc.CreateSession(t.Context(), userID, exp, auth.SessionMeta{})
require.NoError(t, err)
claims := map[string]any{
"jti": userID,
"sub": "access",
"iat": time.Now().Unix(),
"exp": exp.Unix(),
"sid": localSession.ID,
"user_id": userID,
"username": userID,
}
return signJWXToken(t, signingKey, claims)
}
type staticPermissionResolver struct {
ps *authz.PermissionSet
}
func (r staticPermissionResolver) ResolvePermissions(_ context.Context, _ string) (*authz.PermissionSet, error) {
return r.ps, nil
}
func (r staticPermissionResolver) ResolveApiKeyPermissions(_ context.Context, _ string) (*authz.PermissionSet, error) {
return r.ps, nil
}
type testOperationProvider struct {
operation *huma.Operation
}
func (p testOperationProvider) Operation() *huma.Operation {
return p.operation
}
type testEnvironmentTokenResolver struct {
env *environment.Environment
}
func (r testEnvironmentTokenResolver) ResolveEnvironmentByAccessToken(_ context.Context, token string) (*environment.Environment, error) {
if r.env != nil && r.env.AccessToken != nil && *r.env.AccessToken == token {
return r.env, nil
}
return nil, ErrInvalidEnvironmentAccessTokenForTest
}
var ErrInvalidEnvironmentAccessTokenForTest = context.Canceled
type testApiKeyValidator struct {
user *user.User
key *apikey.ApiKey
}
func (v testApiKeyValidator) ValidateApiKeyWithID(_ context.Context, rawKey string) (*user.User, *apikey.ApiKey, error) {
if rawKey == "valid-key" {
return v.user, v.key, nil
}
return nil, nil, context.Canceled
}
// testPermissionResolver returns distinguishable sets so tests can tell which
// resolution path the middleware took: user roles vs per-key grants.
type testPermissionResolver struct{}
func (testPermissionResolver) ResolvePermissions(_ context.Context, _ string) (*authz.PermissionSet, error) {
ps := authz.NewPermissionSet()
ps.AddGlobal("containers:list")
return ps, nil
}
func (testPermissionResolver) ResolveApiKeyPermissions(_ context.Context, _ string) (*authz.PermissionSet, error) {
ps := authz.NewPermissionSet()
ps.AddGlobal("images:list")
return ps, nil
}
func TestAuthMiddleware_ManagerAuthResolvesPermissionsByKeyKind(t *testing.T) {
userID := "key-owner"
owner := &user.User{ID: userID, Username: "owner"}
cases := []struct {
name string
kind string
wantAllowed string
wantDenied string
}{
{name: "personal key inherits owner role permissions", kind: apikey.ApiKeyKindPersonal, wantAllowed: "containers:list", wantDenied: "images:list"},
{name: "scoped key limited to its own grants", kind: apikey.ApiKeyKindScoped, wantAllowed: "images:list", wantDenied: "containers:list"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
router := echo.New()
router.Use(
NewAuthMiddleware(nil, &config.Config{}).
WithApiKeyValidator(testApiKeyValidator{
user: owner,
key: &apikey.ApiKey{ID: "key-1", Kind: tc.kind, UserID: &userID},
}).
WithPermissionResolver(testPermissionResolver{}).
Add(),
)
router.GET("/secure", func(c *echo.Context) error {
ps, ok := c.Get("userPermissions").(*authz.PermissionSet)
require.True(t, ok)
require.True(t, ps.Allows(tc.wantAllowed, ""))
require.False(t, ps.Allows(tc.wantDenied, ""))
return c.JSON(http.StatusOK, map[string]any{"ok": true})
})
req := httptest.NewRequest(http.MethodGet, "/secure", http.NoBody)
req.Header.Set("X-API-Key", "valid-key")
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
})
}
t.Run("browser cookie uses owner role permissions", func(t *testing.T) {
ctx := t.Context()
db := setupAuthMiddlewareTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
sessionSvc := session.NewSessionService(db)
settingsSvc, err := newSettingsServiceForAuthTest(t, ctx, db)
require.NoError(t, err)
authSvc := newTestAuthService()
authSvc.userService = userSvc
authSvc.settingsService = settingsSvc
authSvc.sessionService = sessionSvc
browserUser := &user.User{ID: "browser-owner", Username: "browser-owner"}
_, err = userSvc.CreateUser(ctx, browserUser)
require.NoError(t, err)
expiresAt := time.Now().Add(time.Hour)
browserSession, refreshJTI, err := sessionSvc.CreateSession(ctx, browserUser.ID, expiresAt, auth.SessionMeta{})
require.NoError(t, err)
tokenPair, err := authSvc.buildTokenPair(ctx, browserUser, browserSession, refreshJTI)
require.NoError(t, err)
router := echo.New()
router.Use(
NewAuthMiddleware(authSvc, &config.Config{}).
WithPermissionResolver(testPermissionResolver{}).
Add(),
)
router.GET("/secure", func(c *echo.Context) error {
ps, ok := c.Get("userPermissions").(*authz.PermissionSet)
require.True(t, ok)
require.True(t, ps.Allows("containers:list", ""))
return c.NoContent(http.StatusOK)
})
req := httptest.NewRequest(http.MethodGet, "/secure", http.NoBody)
req.Header.Set("Authorization", "Bearer "+tokenPair.BrowserToken)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusUnauthorized, rec.Code)
req = httptest.NewRequest(http.MethodGet, "/secure", http.NoBody)
req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: tokenPair.BrowserToken})
rec = httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
})
}
func TestAuthMiddleware_ManagerAuthEnvironmentAccessToken(t *testing.T) {
token := "env-access-token"
cases := []struct {
name string
header string
adminRequired bool
wantStatus int
}{
{name: "agent token ordinary route", header: "X-Arcane-Agent-Token", wantStatus: http.StatusOK},
{name: "API key ordinary route", header: "X-API-Key", wantStatus: http.StatusOK},
{name: "agent token admin route", header: "X-Arcane-Agent-Token", adminRequired: true, wantStatus: http.StatusForbidden},
{name: "API key admin route", header: "X-API-Key", adminRequired: true, wantStatus: http.StatusForbidden},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
router := echo.New()
authMiddleware := NewAuthMiddleware(nil, &config.Config{}).
WithEnvironmentAccessTokenResolver(testEnvironmentTokenResolver{
env: &environment.Environment{
ID: "env-self",
Name: "Self Target",
AccessToken: &token,
},
})
if tc.adminRequired {
authMiddleware = authMiddleware.WithAdminRequired()
}
router.Use(authMiddleware.Add())
called := false
router.GET("/secure", func(c *echo.Context) error {
called = true
currentUser := c.Get("currentUser")
require.NotNil(t, currentUser)
authenticatedUser, ok := currentUser.(*user.User)
require.True(t, ok)
require.Equal(t, "environment:env-self", authenticatedUser.ID)
require.Equal(t, "Self Target", authenticatedUser.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": authenticatedUser.ID})
})
req := httptest.NewRequest(http.MethodGet, "/secure", http.NoBody)
req.Header.Set(tc.header, token)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, tc.wantStatus, rec.Code)
require.Equal(t, !tc.adminRequired, called)
if tc.adminRequired {
require.JSONEq(t, `{"statusCode":0,"code":"FORBIDDEN","message":"You don't have permission to access this resource"}`, rec.Body.String())
} else {
require.Contains(t, rec.Body.String(), "environment:env-self")
}
})
}
}