Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: prevent credential reuse after target URL changes (#3317)
Kyle Mendellfe31693634f4
diff --git a/backend/internal/services/container_registry_service.go b/backend/internal/services/container_registry_service.goindex 0cdfbeeb7..f2914b17a 100644--- a/backend/internal/services/container_registry_service.go+++ b/backend/internal/services/container_registry_service.go@@ -21,6 +21,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/utils""github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cache"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation""github.com/getarcaneapp/arcane/types/v2/containerregistry"dockerregistry "github.com/moby/moby/api/types/registry""github.com/moby/moby/client"@@ -188,16 +189,29 @@ func (s *ContainerRegistryService) UpdateRegistry(ctx context.Context, id stringreturn nil, err}+ if err := s.applyRegistryTypeUpdateInternal(registry, req.RegistryType); err != nil {+ return nil, err+ }++ if registry.RegistryType != registryTypeECR {+ if err := validation.ValidateCredentialTargetChange(+ "registry URL",+ registry.URL,+ req.URL,+ normalizeRegistryServerAddressInternal,+ map[string]bool{"token": registry.Token != ""},+ map[string]bool{"token": req.Token != nil && *req.Token != ""},+ ); err != nil {+ return nil, err+ }+ }+// Update common fieldsutils.UpdateIfChanged(®istry.URL, req.URL)utils.UpdateIfChanged(®istry.Description, req.Description)utils.UpdateIfChanged(®istry.Insecure, req.Insecure)utils.UpdateIfChanged(®istry.Enabled, req.Enabled)- if err := s.applyRegistryTypeUpdateInternal(registry, req.RegistryType); err != nil {- return nil, err- }-if registry.RegistryType == registryTypeECR {if err := s.updateECRRegistryFieldsInternal(registry, req); err != nil {return nil, errdiff --git a/backend/internal/services/container_registry_service_test.go b/backend/internal/services/container_registry_service_test.goindex 6a793549a..a210b4976 100644--- a/backend/internal/services/container_registry_service_test.go+++ b/backend/internal/services/container_registry_service_test.go@@ -433,6 +433,89 @@ func TestContainerRegistryService_UpdateRegistry_KeepsExistingTokenWhenNotProvidassert.Equal(t, originalToken, updated.Token)}+func TestContainerRegistryService_UpdateRegistry_RejectsTargetChangeWhenStoredTokenWouldBeReused(t *testing.T) {+ tests := []struct {+ name string+ token *string+ }{+ {name: "omitted token"},+ {name: "empty token", token: new("")},+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ _, db := setupImageServiceAuthTest(t)+ svc := NewContainerRegistryService(db, nil, nil)++ registry, err := svc.CreateRegistry(context.Background(), models.CreateContainerRegistryRequest{+ URL: "https://registry.example.com",+ Username: "my-user",+ Token: "my-token",+ })+ require.NoError(t, err)+ originalToken := registry.Token++ _, err = svc.UpdateRegistry(context.Background(), registry.ID, models.UpdateContainerRegistryRequest{+ URL: new("https://attacker.example.com"),+ Token: tt.token,+ })+ require.Error(t, err)++ var validationErr *models.ValidationError+ require.ErrorAs(t, err, &validationErr)+ assert.Equal(t, "token", validationErr.Field)++ stored, loadErr := svc.GetRegistryByID(context.Background(), registry.ID)+ require.NoError(t, loadErr)+ assert.Equal(t, "https://registry.example.com", stored.URL)+ assert.Equal(t, originalToken, stored.Token)+ })+ }+}++func TestContainerRegistryService_UpdateRegistry_AllowsPathChangeOnSameHostWithoutToken(t *testing.T) {+ _, db := setupImageServiceAuthTest(t)+ svc := NewContainerRegistryService(db, nil, nil)++ registry, err := svc.CreateRegistry(context.Background(), models.CreateContainerRegistryRequest{+ URL: "https://registry.example.com/one",+ Username: "my-user",+ Token: "my-token",+ })+ require.NoError(t, err)+ originalToken := registry.Token++ updated, err := svc.UpdateRegistry(context.Background(), registry.ID, models.UpdateContainerRegistryRequest{+ URL: new("REGISTRY.EXAMPLE.COM/two"),+ })+ require.NoError(t, err)+ assert.Equal(t, "REGISTRY.EXAMPLE.COM/two", updated.URL)+ assert.Equal(t, originalToken, updated.Token)+}++func TestContainerRegistryService_UpdateRegistry_AllowsTargetChangeWhenTokenIsResupplied(t *testing.T) {+ _, db := setupImageServiceAuthTest(t)+ svc := NewContainerRegistryService(db, nil, nil)++ registry, err := svc.CreateRegistry(context.Background(), models.CreateContainerRegistryRequest{+ URL: "https://registry.example.com",+ Username: "my-user",+ Token: "my-token",+ })+ require.NoError(t, err)++ updated, err := svc.UpdateRegistry(context.Background(), registry.ID, models.UpdateContainerRegistryRequest{+ URL: new("https://registry.example.net"),+ Token: new("new-token"),+ })+ require.NoError(t, err)+ assert.Equal(t, "https://registry.example.net", updated.URL)++ decryptedToken, decryptErr := crypto.Decrypt(updated.Token)+ require.NoError(t, decryptErr)+ assert.Equal(t, "new-token", decryptedToken)+}+func TestContainerRegistryService_UpdateRegistry_RejectsChangingRegistryType(t *testing.T) {_, db := setupImageServiceAuthTest(t)svc := NewContainerRegistryService(db, nil, nil)diff --git a/backend/internal/services/git_repository_service.go b/backend/internal/services/git_repository_service.goindex 80173e9b5..1d8c28cd0 100644--- a/backend/internal/services/git_repository_service.go+++ b/backend/internal/services/git_repository_service.go@@ -12,6 +12,7 @@ import ("github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts""github.com/getarcaneapp/arcane/backend/v2/pkg/pagination""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation""github.com/getarcaneapp/arcane/types/v2/gitops"contextsource "go.getarcane.app/builds/pkg/utils/contextsource""go.getarcane.app/sys/crypto"@@ -170,7 +171,20 @@ func (s *GitRepositoryService) UpdateRepository(ctx context.Context, id string,return nil, err}- if err := validateGitRepositoryCredentialChangeInternal(repository, req); err != nil {+ if err := validation.ValidateCredentialTargetChange(+ "repository URL",+ repository.URL,+ req.URL,+ nil,+ map[string]bool{+ "sshKey": repository.SSHKey != "",+ "token": repository.Token != "",+ },+ map[string]bool{+ "sshKey": req.SSHKey != nil,+ "token": req.Token != nil,+ },+ ); err != nil {return nil, err}@@ -244,39 +258,6 @@ func (s *GitRepositoryService) UpdateRepository(ctx context.Context, id string,return s.GetRepositoryByID(ctx, id)}-func validateGitRepositoryCredentialChangeInternal(repository *models.GitRepository, req models.UpdateGitRepositoryRequest) error {- if repository == nil || req.URL == nil || *req.URL == repository.URL {- return nil- }-- missingFields := make([]string, 0, 2)- missingCredentialLabels := make([]string, 0, 2)-- if repository.Token != "" && req.Token == nil {- missingFields = append(missingFields, "token")- missingCredentialLabels = append(missingCredentialLabels, "token")- }-- if repository.SSHKey != "" && req.SSHKey == nil {- missingFields = append(missingFields, "sshKey")- missingCredentialLabels = append(missingCredentialLabels, "SSH key")- }-- if len(missingFields) == 0 {- return nil- }-- if len(missingFields) == 1 {- field := missingFields[0]- return &models.ValidationError{Field: field, Message: "Changing repository URL requires re-supplying or clearing the " + missingCredentialLabels[0]}- }-- return models.NewValidationError(- "Changing repository URL requires re-supplying or clearing all stored credentials: "+strings.Join(missingCredentialLabels, " and "),- map[string]any{"fields": missingFields},- )-}-func (s *GitRepositoryService) DeleteRepository(ctx context.Context, id string, actor models.User) error {// Check if repository is used by any syncsvar count int64diff --git a/backend/internal/services/git_repository_service_test.go b/backend/internal/services/git_repository_service_test.goindex a233e8597..872196dc8 100644--- a/backend/internal/services/git_repository_service_test.go+++ b/backend/internal/services/git_repository_service_test.go@@ -78,7 +78,7 @@ func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredTokenWovar validationErr *models.ValidationErrorrequire.ErrorAs(t, err, &validationErr)assert.Equal(t, "token", validationErr.Field)- assert.Contains(t, validationErr.Message, "re-supplying or clearing the token")+ assert.Contains(t, validationErr.Message, "repository URL")stored, loadErr := svc.GetRepositoryByID(context.Background(), repo.ID)require.NoError(t, loadErr)@@ -103,7 +103,7 @@ func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredSSHKeyWvar validationErr *models.ValidationErrorrequire.ErrorAs(t, err, &validationErr)assert.Equal(t, "sshKey", validationErr.Field)- assert.Contains(t, validationErr.Message, "re-supplying or clearing the SSH key")+ assert.Contains(t, validationErr.Message, "repository URL")stored, loadErr := svc.GetRepositoryByID(context.Background(), repo.ID)require.NoError(t, loadErr)@@ -130,8 +130,8 @@ func TestGitRepositoryService_UpdateRepository_RejectsURLChangeWhenStoredTokenAnvar apiErr *models.APIErrorrequire.ErrorAs(t, err, &apiErr)assert.Equal(t, models.APIErrorCodeValidationError, apiErr.Code)- assert.Contains(t, apiErr.Message, "token and SSH key")- assert.Equal(t, map[string]any{"fields": []string{"token", "sshKey"}}, apiErr.Details)+ assert.Contains(t, apiErr.Message, "repository URL")+ assert.Equal(t, map[string]any{"fields": []string{"sshKey", "token"}}, apiErr.Details)}func TestGitRepositoryService_UpdateRepository_AllowsURLChangeWhenTokenIsResupplied(t *testing.T) {diff --git a/backend/pkg/utils/validation/credential_target.go b/backend/pkg/utils/validation/credential_target.gonew file mode 100644index 000000000..01bbd6106--- /dev/null+++ b/backend/pkg/utils/validation/credential_target.go@@ -0,0 +1,53 @@+package validation++import (+ "fmt"+ "slices"++ "github.com/getarcaneapp/arcane/backend/v2/internal/models"+)++// ValidateCredentialTargetChange prevents stored credentials from being reused+// against a changed target unless the update explicitly handles them.+func ValidateCredentialTargetChange(+ targetName string,+ currentTarget string,+ nextTarget *string,+ normalize func(string) string,+ storedCredentials map[string]bool,+ updatedCredentials map[string]bool,+) error {+ if nextTarget == nil {+ return nil+ }++ if normalize == nil {+ normalize = func(value string) string { return value }+ }+ if normalize(currentTarget) == normalize(*nextTarget) {+ return nil+ }++ missingFields := make([]string, 0, len(storedCredentials))+ for field, stored := range storedCredentials {+ if stored && !updatedCredentials[field] {+ missingFields = append(missingFields, field)+ }+ }+ if len(missingFields) == 0 {+ return nil+ }++ slices.Sort(missingFields)+ if len(missingFields) == 1 {+ return &models.ValidationError{+ Field: missingFields[0],+ Message: fmt.Sprintf("Changing %s requires re-supplying or clearing the %s", targetName, missingFields[0]),+ }+ }++ return models.NewValidationError(+ fmt.Sprintf("Changing %s requires updating all stored credentials", targetName),+ map[string]any{"fields": missingFields},+ )+}diff --git a/backend/pkg/utils/validation/credential_target_test.go b/backend/pkg/utils/validation/credential_target_test.gonew file mode 100644index 000000000..8819d32c6--- /dev/null+++ b/backend/pkg/utils/validation/credential_target_test.go@@ -0,0 +1,107 @@+package validation++import (+ "strings"+ "testing"++ "github.com/getarcaneapp/arcane/backend/v2/internal/models"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestValidateCredentialTargetChange(t *testing.T) {+ normalizeHost := func(value string) string {+ return strings.TrimPrefix(strings.ToLower(value), "https://")+ }++ tests := []struct {+ name string+ currentTarget string+ nextTarget *string+ normalize func(string) string+ storedCredentials map[string]bool+ updatedCredentials map[string]bool+ wantField string+ wantFields []string+ }{+ {+ name: "omitted target",+ currentTarget: "registry.example.com",+ storedCredentials: map[string]bool{"token": true},+ },+ {+ name: "identical target",+ currentTarget: "registry.example.com",+ nextTarget: new("registry.example.com"),+ storedCredentials: map[string]bool{"token": true},+ },+ {+ name: "normalized target alias",+ currentTarget: "https://registry.example.com",+ nextTarget: new("REGISTRY.EXAMPLE.COM"),+ normalize: normalizeHost,+ storedCredentials: map[string]bool{"token": true},+ },+ {+ name: "changed target without stored credentials",+ currentTarget: "registry.example.com",+ nextTarget: new("registry.example.net"),+ },+ {+ name: "changed target with replacement",+ currentTarget: "registry.example.com",+ nextTarget: new("registry.example.net"),+ storedCredentials: map[string]bool{"token": true},+ updatedCredentials: map[string]bool{"token": true},+ },+ {+ name: "changed target with clearing",+ currentTarget: "git.example.com/repo",+ nextTarget: new("git.example.net/repo"),+ storedCredentials: map[string]bool{"sshKey": true},+ updatedCredentials: map[string]bool{"sshKey": true},+ },+ {+ name: "changed target with one missing credential",+ currentTarget: "registry.example.com",+ nextTarget: new("registry.example.net"),+ storedCredentials: map[string]bool{"token": true},+ wantField: "token",+ },+ {+ name: "missing fields are deterministic",+ currentTarget: "git.example.com/repo",+ nextTarget: new("git.example.net/repo"),+ storedCredentials: map[string]bool{"token": true, "sshKey": true},+ wantFields: []string{"sshKey", "token"},+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ err := ValidateCredentialTargetChange(+ "credential target",+ tt.currentTarget,+ tt.nextTarget,+ tt.normalize,+ tt.storedCredentials,+ tt.updatedCredentials,+ )++ switch {+ case tt.wantField != "":+ var validationErr *models.ValidationError+ require.ErrorAs(t, err, &validationErr)+ assert.Equal(t, tt.wantField, validationErr.Field)+ assert.Equal(t, "Changing credential target requires re-supplying or clearing the token", validationErr.Message)+ case len(tt.wantFields) > 0:+ var apiErr *models.APIError+ require.ErrorAs(t, err, &apiErr)+ assert.Equal(t, models.APIErrorCodeValidationError, apiErr.Code)+ assert.Equal(t, map[string]any{"fields": tt.wantFields}, apiErr.Details)+ default:+ require.NoError(t, err)+ }+ })+ }+}