Skip to content

Modern Docker Management, Designed for Everyone

chore: fix linter, refactor admin claim logic

Kyle Mendella97097a291df
diff --git a/backend/internal/services/auth_service.go b/backend/internal/services/auth_service.go
index 50fac80d3..86fbd7eb4 100644
--- a/backend/internal/services/auth_service.go
+++ b/backend/internal/services/auth_service.go
@@ -2,14 +2,12 @@ package services
import (
"context"
- "encoding/base64"
"encoding/json"
"errors"
"fmt"
"strings"
"time"
- "github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"github.com/google/uuid"
"github.com/ofkm/arcane-backend/internal/config"
@@ -81,26 +79,18 @@ func NewAuthService(userService *UserService, settingsService *SettingsService,
}
}
-func getClientIP(ctx context.Context) string {
- if ginCtx, ok := ctx.(*gin.Context); ok {
- return ginCtx.ClientIP()
- }
- return ""
-}
-
func (s *AuthService) getAuthSettings(ctx context.Context) (*AuthSettings, error) {
settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
- // Normalize using GetSessionTimeout so UI sees the same effective minutes we enforce
timeoutMinutes, _ := s.GetSessionTimeout(ctx)
authSettings := &AuthSettings{
LocalAuthEnabled: settings.AuthLocalEnabled.IsTrue(),
OidcEnabled: settings.AuthOidcEnabled.IsTrue(),
- SessionTimeout: timeoutMinutes, // minutes
+ SessionTimeout: timeoutMinutes,
}
if authSettings.OidcEnabled && settings.AuthOidcConfig.Value != "" {
@@ -238,9 +228,8 @@ func (s *AuthService) Login(ctx context.Context, username, password string) (*mo
}
metadata := models.JSON{
- "action": "login",
- "method": "local",
- "ipAddress": getClientIP(ctx),
+ "action": "login",
+ "method": "local",
}
if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
fmt.Printf("Could not log user login action: %s\n", logErr)
@@ -265,11 +254,10 @@ func (s *AuthService) OidcLogin(ctx context.Context, userInfo dto.OidcUserInfo,
}
metadata := models.JSON{
- "action": "login",
- "method": "oidc",
- "newUser": isNewUser,
- "subject": userInfo.Subject,
- "ipAddress": getClientIP(ctx),
+ "action": "login",
+ "method": "oidc",
+ "newUser": isNewUser,
+ "subject": userInfo.Subject,
}
if logErr := s.eventService.LogUserEvent(ctx, models.EventTypeUserLogin, user.ID, user.Username, metadata); logErr != nil {
fmt.Printf("Could not log OIDC user login action: %s\n", logErr)
@@ -352,7 +340,6 @@ func (s *AuthService) updateOidcUser(ctx context.Context, user *models.User, use
user.Email = &userInfo.Email
}
- // Sync admin role to current mapping result
wantAdmin := s.isAdminFromOidc(ctx, userInfo, tokenResp)
hasAdmin := hasRole(user.Roles, "admin")
switch {
@@ -397,44 +384,18 @@ func removeRole(roles models.StringSlice, role string) models.StringSlice {
}
func (s *AuthService) isAdminFromOidc(ctx context.Context, userInfo dto.OidcUserInfo, tokenResp *dto.OidcTokenResponse) bool {
- // 1) Configured claim mapping
- if claimKey, values := s.getAdminClaimConfig(ctx); claimKey != "" {
- // Check userinfo raw claims
- if v, ok := getByPath(userInfo.Extra, claimKey); ok {
- if evalAdminMatch(v, values) {
- return true
- }
- }
- // Check ID token payload if present
- if tokenResp != nil && tokenResp.IDToken != "" {
- if claims := parseJWTClaims(tokenResp.IDToken); claims != nil {
- if v, ok := getByPath(claims, claimKey); ok && evalAdminMatch(v, values) {
- return true
- }
- }
- }
+ claimKey, values := s.getAdminClaimConfig(ctx)
+ if claimKey == "" {
+ return false
}
- // 2) Heuristics fallback (common providers)
- if userInfo.Admin {
- return true
- }
- if sliceContainsFold(userInfo.Roles, "admin") || sliceContainsFold(userInfo.Groups, "admin") {
+ if v, ok := utils.GetByPath(userInfo.Extra, claimKey); ok && utils.EvalMatch(v, values) {
return true
}
+
if tokenResp != nil && tokenResp.IDToken != "" {
- if claims := parseJWTClaims(tokenResp.IDToken); claims != nil {
- // realm_access.roles, roles, groups, admin:true
- if v, ok := getByPath(claims, "realm_access.roles"); ok && evalAdminMatch(v, []string{"admin"}) {
- return true
- }
- if v, ok := getByPath(claims, "roles"); ok && evalAdminMatch(v, []string{"admin"}) {
- return true
- }
- if v, ok := getByPath(claims, "groups"); ok && evalAdminMatch(v, []string{"admin"}) {
- return true
- }
- if v, ok := claims["admin"]; ok && evalAdminMatch(v, []string{"true"}) {
+ if claims := utils.ParseJWTClaims(tokenResp.IDToken); claims != nil {
+ if v, ok := utils.GetByPath(claims, claimKey); ok && utils.EvalMatch(v, values) {
return true
}
}
@@ -454,7 +415,6 @@ func (s *AuthService) getAdminClaimConfig(ctx context.Context) (claim string, va
return "", nil
}
if raw == "" {
- // Treat truthy/true for boolean claims if no explicit values provided
return claim, nil
}
parts := strings.Split(raw, ",")
@@ -467,93 +427,6 @@ func (s *AuthService) getAdminClaimConfig(ctx context.Context) (claim string, va
return claim, values
}
-func parseJWTClaims(idToken string) map[string]any {
- parts := strings.Split(idToken, ".")
- if len(parts) < 2 {
- return nil
- }
- payload, err := base64.RawURLEncoding.DecodeString(parts[1])
- if err != nil {
- return nil
- }
- var claims map[string]any
- if err := json.Unmarshal(payload, &claims); err != nil {
- return nil
- }
- return claims
-}
-
-func getByPath(m map[string]any, path string) (any, bool) {
- if m == nil {
- return nil, false
- }
- keys := strings.Split(path, ".")
- var cur any = m
- for _, k := range keys {
- obj, ok := cur.(map[string]any)
- if !ok {
- return nil, false
- }
- v, ok := obj[k]
- if !ok {
- return nil, false
- }
- cur = v
- }
- return cur, true
-}
-
-func evalAdminMatch(v any, want []string) bool {
- // No explicit values => accept truthy bool
- if len(want) == 0 {
- if b, ok := v.(bool); ok {
- return b
- }
- // no values for non-bool: do not match
- return false
- }
-
- // Normalize want set (lower-cased)
- wantSet := map[string]struct{}{}
- for _, s := range want {
- wantSet[strings.ToLower(s)] = struct{}{}
- }
-
- switch x := v.(type) {
- case string:
- _, ok := wantSet[strings.ToLower(x)]
- return ok
- case []any:
- for _, it := range x {
- if s, ok := it.(string); ok {
- if _, ok2 := wantSet[strings.ToLower(s)]; ok2 {
- return true
- }
- }
- }
- return false
- case map[string]any:
- // Unexpected: nested object; no match
- return false
- case bool:
- // Compare against accepted strings like "true"/"1"
- _, ok := wantSet[strings.ToLower(fmt.Sprintf("%v", x))]
- return ok
- default:
- return false
- }
-}
-
-func sliceContainsFold(ss []string, want string) bool {
- want = strings.ToLower(want)
- for _, s := range ss {
- if strings.ToLower(s) == want {
- return true
- }
- }
- return false
-}
-
func (s *AuthService) persistOidcTokens(user *models.User, tokenResp *dto.OidcTokenResponse) {
if tokenResp == nil {
return
diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.go
index dfc2462f7..1a3722e0b 100644
--- a/backend/internal/services/oidc_service.go
+++ b/backend/internal/services/oidc_service.go
@@ -289,11 +289,18 @@ func (s *OidcService) getUserInfo(ctx context.Context, config *models.OidcConfig
return nil, err
}
- // Map known fields into struct, keep raw claims
- b, _ := json.Marshal(raw)
- var userInfo dto.OidcUserInfo
- _ = json.Unmarshal(b, &userInfo)
- userInfo.Extra = raw
+ userInfo := dto.OidcUserInfo{
+ Subject: utils.GetStringClaim(raw, "sub"),
+ Name: utils.GetStringClaim(raw, "name"),
+ Email: utils.GetStringClaim(raw, "email"),
+ PreferredUsername: utils.GetStringClaim(raw, "preferred_username"),
+ GivenName: utils.GetStringClaim(raw, "given_name"),
+ FamilyName: utils.GetStringClaim(raw, "family_name"),
+ Admin: utils.GetBoolClaim(raw, "admin"),
+ Roles: utils.GetStringSliceClaim(raw, "roles"),
+ Groups: utils.GetStringSliceClaim(raw, "groups"),
+ Extra: raw,
+ }
if userInfo.Subject == "" {
return nil, errors.New("missing required 'sub' field in userinfo response")
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index d96f00994..5a82d70a7 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -403,77 +403,89 @@ func (s *UpdaterService) isUpdateDisabled(labels map[string]string) bool {
return false
}
-func (s *UpdaterService) collectUsedImages(ctx context.Context) (map[string]struct{}, error) {
- out := map[string]struct{}{}
+// collectUsedImagesFromContainers adds normalized image tags from non-opted-out running containers.
+func (s *UpdaterService) collectUsedImagesFromContainers(ctx context.Context, dcli *client.Client, out map[string]struct{}) error {
+ if dcli == nil {
+ return nil
+ }
+ list, err := dcli.ContainerList(ctx, container.ListOptions{All: false})
+ if err != nil {
+ return err
+ }
+ for _, c := range list {
+ if s.isUpdateDisabled(c.Labels) {
+ continue
+ }
+ inspect, err := dcli.ContainerInspect(ctx, c.ID)
+ if err != nil {
+ continue
+ }
+ if inspect.Config != nil && s.isUpdateDisabled(inspect.Config.Labels) {
+ continue
+ }
+ for _, t := range s.getNormalizedTagsForContainer(ctx, dcli, inspect) {
+ out[t] = struct{}{}
+ }
+ }
+ return nil
+}
- // Running containers
- dcli, err := s.dockerService.CreateConnection(ctx)
- if err == nil {
- defer dcli.Close()
- list, err := dcli.ContainerList(ctx, container.ListOptions{All: false})
- if err == nil {
- for _, c := range list {
- // Skip containers with opt-out label
- if s.isUpdateDisabled(c.Labels) {
- continue
- }
- inspect, err := dcli.ContainerInspect(ctx, c.ID)
- if err != nil {
- continue
- }
- // Also honor labels from the full inspect if present
- if inspect.Config != nil && s.isUpdateDisabled(inspect.Config.Labels) {
- continue
- }
- for _, t := range s.getNormalizedTagsForContainer(ctx, dcli, inspect) {
- out[t] = struct{}{}
- }
- }
+func (s *UpdaterService) isStackOptedOut(ctx context.Context, dcli *client.Client, stackName string) bool {
+ containers, err := s.getStackContainers(ctx, dcli, stackName)
+ if err != nil {
+ return false
+ }
+ for _, c := range containers {
+ if s.isUpdateDisabled(c.Labels) {
+ return true
}
}
+ return false
+}
- // Running stacks (service definitions)
- stacks, err2 := s.stackService.ListStacks(ctx)
- if err2 == nil {
- for _, st := range stacks {
- if st.Status != models.StackStatusRunning {
+func (s *UpdaterService) collectUsedImagesFromStacks(ctx context.Context, dcli *client.Client, out map[string]struct{}) error {
+ stacks, err := s.stackService.ListStacks(ctx)
+ if err != nil {
+ return err
+ }
+ for _, st := range stacks {
+ if st.Status != models.StackStatusRunning {
+ continue
+ }
+ if dcli != nil && s.isStackOptedOut(ctx, dcli, st.Name) {
+ continue
+ }
+ srvs, err := s.stackService.GetStackServices(ctx, st.ID)
+ if err != nil {
+ continue
+ }
+ for _, svc := range srvs {
+ if svc.Image == "" {
continue
}
+ out[s.normalizeRef(svc.Image)] = struct{}{}
+ }
+ }
+ return nil
+}
- // If any container in the stack has the opt-out label, skip the entire stack
- disabledStack := false
- if dcli != nil {
- if cs, err := s.getStackContainers(ctx, dcli, st.Name); err == nil {
- for _, c := range cs {
- if s.isUpdateDisabled(c.Labels) {
- disabledStack = true
- break
- }
- }
- }
- }
- if disabledStack {
- continue
- }
+func (s *UpdaterService) collectUsedImages(ctx context.Context) (map[string]struct{}, error) {
+ out := map[string]struct{}{}
- srvs, err := s.stackService.GetStackServices(ctx, st.ID)
- if err != nil {
- continue
- }
- for _, svc := range srvs {
- if svc.Image == "" {
- continue
- }
- out[s.normalizeRef(svc.Image)] = struct{}{}
- }
- }
+ // Try to connect to Docker once; proceed with stacks even if it fails.
+ dcli, err := s.dockerService.CreateConnection(ctx)
+ if err != nil {
+ _ = err // keep going without container details
+ } else {
+ defer dcli.Close()
}
+ _ = s.collectUsedImagesFromContainers(ctx, dcli, out)
+ _ = s.collectUsedImagesFromStacks(ctx, dcli, out)
+
return out, nil
}
-// Resolve a container's image to all normalized repo:tags that reference it.
-// Falls back to the config image reference as a tag if present.
func (s *UpdaterService) getNormalizedTagsForContainer(ctx context.Context, dcli *client.Client, inspect container.InspectResponse) []string {
seen := map[string]struct{}{}
@@ -489,7 +501,6 @@ func (s *UpdaterService) getNormalizedTagsForContainer(ctx context.Context, dcli
}
}
- // Fallback to the configured image ref (may already be a tag)
if inspect.Config != nil && inspect.Config.Image != "" {
seen[s.normalizeRef(inspect.Config.Image)] = struct{}{}
}
diff --git a/backend/internal/utils/jwt_util.go b/backend/internal/utils/jwt_util.go
index a64657556..820a8ad7b 100644
--- a/backend/internal/utils/jwt_util.go
+++ b/backend/internal/utils/jwt_util.go
@@ -2,9 +2,84 @@ package utils
import (
"crypto/rand"
+ "encoding/base64"
+ "encoding/json"
"fmt"
+ "strings"
)
+func GetStringClaim(m map[string]any, key string) string {
+ if v, ok := m[key]; ok {
+ switch t := v.(type) {
+ case string:
+ return t
+ case fmt.Stringer:
+ return t.String()
+ }
+ }
+ return ""
+}
+
+func GetBoolClaim(m map[string]any, key string) bool {
+ if v, ok := m[key]; ok {
+ switch t := v.(type) {
+ case bool:
+ return t
+ case string:
+ switch strings.ToLower(strings.TrimSpace(t)) {
+ case "1", "true", "yes", "y", "on":
+ return true
+ }
+ case float64:
+ return t != 0
+ case int, int32, int64:
+ return fmt.Sprintf("%v", t) != "0"
+ }
+ }
+ return false
+}
+
+func GetStringSliceClaim(m map[string]any, key string) []string {
+ v, ok := m[key]
+ if !ok || v == nil {
+ return nil
+ }
+ switch t := v.(type) {
+ case []string:
+ return t
+ case []any:
+ out := make([]string, 0, len(t))
+ for _, it := range t {
+ if s, ok := it.(string); ok && s != "" {
+ out = append(out, s)
+ }
+ }
+ if len(out) > 0 {
+ return out
+ }
+ case string:
+ s := strings.TrimSpace(t)
+ if s == "" {
+ return nil
+ }
+ // Support comma or space separated strings
+ if strings.Contains(s, ",") {
+ parts := strings.Split(s, ",")
+ out := make([]string, 0, len(parts))
+ for _, p := range parts {
+ if ps := strings.TrimSpace(p); ps != "" {
+ out = append(out, ps)
+ }
+ }
+ if len(out) > 0 {
+ return out
+ }
+ }
+ return strings.Fields(s)
+ }
+ return nil
+}
+
func CheckOrGenerateJwtSecret(jwtSecret string) []byte {
var secretBytes []byte
if jwtSecret != "" {
@@ -18,3 +93,81 @@ func CheckOrGenerateJwtSecret(jwtSecret string) []byte {
}
return nil
}
+
+func ParseJWTClaims(idToken string) map[string]any {
+ parts := strings.Split(idToken, ".")
+ if len(parts) < 2 {
+ return nil
+ }
+ payload, err := base64.RawURLEncoding.DecodeString(parts[1])
+ if err != nil {
+ return nil
+ }
+ var claims map[string]any
+ if err := json.Unmarshal(payload, &claims); err != nil {
+ return nil
+ }
+ return claims
+}
+
+func GetByPath(m map[string]any, path string) (any, bool) {
+ if m == nil {
+ return nil, false
+ }
+ keys := strings.Split(path, ".")
+ var cur any = m
+ for _, k := range keys {
+ obj, ok := cur.(map[string]any)
+ if !ok {
+ return nil, false
+ }
+ v, ok := obj[k]
+ if !ok {
+ return nil, false
+ }
+ cur = v
+ }
+ return cur, true
+}
+
+func EvalMatch(v any, want []string) bool {
+ if len(want) == 0 {
+ if b, ok := v.(bool); ok {
+ return b
+ }
+ return false
+ }
+ wantSet := map[string]struct{}{}
+ for _, s := range want {
+ wantSet[strings.ToLower(s)] = struct{}{}
+ }
+ switch x := v.(type) {
+ case string:
+ _, ok := wantSet[strings.ToLower(x)]
+ return ok
+ case []any:
+ for _, it := range x {
+ if s, ok := it.(string); ok {
+ if _, ok2 := wantSet[strings.ToLower(s)]; ok2 {
+ return true
+ }
+ }
+ }
+ return false
+ case bool:
+ _, ok := wantSet[strings.ToLower(fmt.Sprintf("%v", x))]
+ return ok
+ default:
+ return false
+ }
+}
+
+func SliceContainsFold(ss []string, want string) bool {
+ want = strings.ToLower(want)
+ for _, s := range ss {
+ if strings.ToLower(s) == want {
+ return true
+ }
+ }
+ return false
+}