Skip to content

Modern Docker Management, Designed for Everyone

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.go
index 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 string
return 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 fields
utils.UpdateIfChanged(&registry.URL, req.URL)
utils.UpdateIfChanged(&registry.Description, req.Description)
utils.UpdateIfChanged(&registry.Insecure, req.Insecure)
utils.UpdateIfChanged(&registry.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, err
diff --git a/backend/internal/services/container_registry_service_test.go b/backend/internal/services/container_registry_service_test.go
index 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_KeepsExistingTokenWhenNotProvid
assert.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.go
index 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 syncs
var count int64
diff --git a/backend/internal/services/git_repository_service_test.go b/backend/internal/services/git_repository_service_test.go
index 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_RejectsURLChangeWhenStoredTokenWo
var validationErr *models.ValidationError
require.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_RejectsURLChangeWhenStoredSSHKeyW
var validationErr *models.ValidationError
require.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_RejectsURLChangeWhenStoredTokenAn
var apiErr *models.APIError
require.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.go
new file mode 100644
index 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.go
new file mode 100644
index 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)
+ }
+ })
+ }
+}