Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Validate Space slugs in repository

Neeraj Guptaed1f6fb75ae4
diff --git a/server/space/controller/friends_test.go b/server/space/controller/friends_test.go
index fb8495052b..9972f34a70 100644
--- a/server/space/controller/friends_test.go
+++ b/server/space/controller/friends_test.go
@@ -23,7 +23,7 @@ func TestFriendRelationshipReportsSelfFriendAndEmpty(t *testing.T) {
charlieID := insertSpaceControllerUser(t, repos, "[email protected]", "charlie-public")
aliceSpace, err := testCreateSpace(ctx, repos, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, repos, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, repos, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, repos, charlieID, "charlie", "charlie-space-key", "charlie-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
diff --git a/server/space/controller/validation.go b/server/space/controller/validation.go
index f7ff383173..b418c440cb 100644
--- a/server/space/controller/validation.go
+++ b/server/space/controller/validation.go
@@ -2,15 +2,13 @@ package controller
import (
"encoding/base64"
- "regexp"
"strings"
"github.com/ente/museum/ente"
+ "github.com/ente/museum/space/repo"
)
const (
- minSpaceSlugLength = 4
- maxSpaceSlugLength = 30
maxSpaceEncryptedProfileEncodedBytes = 32 * 1024
maxSpaceEncryptedProfileDecodedBytes = 24 * 1024
maxSpaceEncryptedKeyEncodedBytes = 4 * 1024
@@ -24,46 +22,8 @@ const (
maxSpaceObjectKeyBytes = 512
)
-var spaceSlugPattern = regexp.MustCompile(`^[a-z0-9][a-z0-9._]*$`)
-var reservedSpaceSlugs = newReservedSpaceSlugSet()
-
-func normalizeSlug(input string) string {
- return strings.ToLower(strings.TrimSpace(input))
-}
-
-func newReservedSpaceSlugSet() map[string]struct{} {
- slugs := make(map[string]struct{}, len(reservedSpaceSlugList))
- for _, slug := range reservedSpaceSlugList {
- slugs[slug] = struct{}{}
- }
- return slugs
-}
-
func validateSpaceSlug(input string) (string, error) {
- slug := normalizeSlug(input)
- if slug == "" {
- return "", ente.NewBadRequestWithMessage("spaceSlug is required")
- }
- if len(slug) < minSpaceSlugLength || len(slug) > maxSpaceSlugLength {
- return "", ente.NewBadRequestWithMessage("spaceSlug must be 4-30 characters")
- }
- if isReservedSpaceSlug(slug) {
- return "", ente.NewBadRequestWithMessage("spaceSlug is reserved")
- }
- if !spaceSlugPattern.MatchString(slug) {
- return "", ente.NewBadRequestWithMessage("spaceSlug can only contain lowercase letters, numbers, dots, or underscores, and must start with a letter or number")
- }
- return slug, nil
-}
-
-func isReservedSpaceSlug(slug string) bool {
- if _, ok := reservedSpaceSlugs[slug]; ok {
- return true
- }
- if strings.HasPrefix(slug, "ente") {
- return true
- }
- return strings.HasSuffix(slug, ".ente") || strings.HasSuffix(slug, "-ente") || strings.HasSuffix(slug, "_ente")
+ return repo.ValidateSpaceSlug(input)
}
func decodeEncodedSpaceField(field string, value string, maxEncodedBytes int, maxDecodedBytes int) ([]byte, error) {
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index 0c1f955754..e1d08af6b2 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -221,6 +221,57 @@ func TestCreateSpaceEnforcesOneSpacePerOwner(t *testing.T) {
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, userID))
}
+func TestCreateSpaceRejectsInvalidSlug(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ slug string
+ message string
+ }{
+ {name: "reserved", slug: "ente", message: "spaceSlug is reserved"},
+ {name: "invalid syntax", slug: "ali/ce", message: "spaceSlug can only contain"},
+ {name: "too short", slug: "abc", message: "spaceSlug must be 4-30 characters"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := context.Background()
+ userID := insertSpaceUser(t, module, "create-invalid-"+tc.name+"@example.com", "create-invalid-public")
+
+ _, err := testCreateSpace(ctx, module, userID, tc.slug, "root", "public", "secret", "nonce", "profile")
+ require.Error(t, err)
+ require.Contains(t, err.Error(), tc.message)
+ require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, userID))
+ })
+ }
+}
+
+func TestUpdateSlugRejectsInvalidSlug(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ slug string
+ message string
+ }{
+ {name: "reserved", slug: "ente", message: "spaceSlug is reserved"},
+ {name: "invalid syntax", slug: "ali/ce", message: "spaceSlug can only contain"},
+ {name: "too short", slug: "abc", message: "spaceSlug must be 4-30 characters"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ module := newSpaceTestModule(t)
+ ctx := context.Background()
+ userID := insertSpaceUser(t, module, "update-invalid-"+tc.name+"@example.com", "update-invalid-public")
+ space, err := testCreateSpace(ctx, module, userID, "valid_slug", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+
+ _, err = module.Spaces.UpdateSlug(ctx, space.SpaceID, tc.slug)
+ require.Error(t, err)
+ require.Contains(t, err.Error(), tc.message)
+
+ unchanged, err := module.Spaces.GetSpaceByID(ctx, space.SpaceID)
+ require.NoError(t, err)
+ require.Equal(t, "valid_slug", unchanged.SpaceSlug)
+ })
+ }
+}
+
func TestCreatePostEnforcesSpacePostLimit(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
@@ -1293,7 +1344,7 @@ func TestSpaceModuleLifecycle(t *testing.T) {
require.NoError(t, err)
require.Equal(t, 1, aliceSpace.CurrentVersion)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
listedSpaces, err := module.Spaces.ListSpacesByOwner(ctx, aliceID)
@@ -1346,7 +1397,7 @@ func TestSpaceModuleLifecycle(t *testing.T) {
friends, err := module.Friends.ListFriendsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, friends, 1)
- require.Equal(t, "bob", friends[0].Friend.SpaceSlug)
+ require.Equal(t, "bobb", friends[0].Friend.SpaceSlug)
bobFriends, err := module.Friends.ListFriendsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
@@ -1631,7 +1682,7 @@ func TestAddFriendCreatesReciprocalShares(t *testing.T) {
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
@@ -1670,7 +1721,7 @@ func TestCreateFriendRequestRejectsExistingFriends(t *testing.T) {
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
@@ -1735,7 +1786,7 @@ func TestUpdateShareOnlyRefreshesExistingShares(t *testing.T) {
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testUpsertShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "share-key-v1", aliceSpace.CurrentVersion)
@@ -1834,7 +1885,7 @@ func TestAddFriendRejectsStaleKeyVersion(t *testing.T) {
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
_, err = testRotateKey(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
@@ -1856,7 +1907,7 @@ func TestUpdateShareRejectsStaleKeyVersion(t *testing.T) {
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testUpsertShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "share-key-v1", aliceSpace.CurrentVersion)
require.NoError(t, err)
@@ -1962,7 +2013,7 @@ func TestListFeedCursorUsesCreatedAtSortOrder(t *testing.T) {
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
- bobSpace, err := testCreateSpace(ctx, module, bobID, "bob", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
+ bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie", "charlie-space-key", "charlie-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
diff --git a/server/space/controller/reserved_space_slugs.go b/server/space/repo/reserved_space_slugs.go
similarity index 99%
rename from server/space/controller/reserved_space_slugs.go
rename to server/space/repo/reserved_space_slugs.go
index d6530541ce..db75ea7cd4 100644
--- a/server/space/controller/reserved_space_slugs.go
+++ b/server/space/repo/reserved_space_slugs.go
@@ -1,4 +1,4 @@
-package controller
+package repo
var reservedSpaceSlugList = []string{
"2fa",
diff --git a/server/space/repo/slug_validation.go b/server/space/repo/slug_validation.go
new file mode 100644
index 0000000000..16a4e79b75
--- /dev/null
+++ b/server/space/repo/slug_validation.go
@@ -0,0 +1,59 @@
+package repo
+
+import (
+ "regexp"
+ "strings"
+
+ "github.com/ente/museum/ente"
+)
+
+const (
+ minSpaceSlugLength = 4
+ maxSpaceSlugLength = 30
+)
+
+var spaceSlugPattern = regexp.MustCompile(`^[a-z0-9][a-z0-9._]*$`)
+var reservedSpaceSlugs = newReservedSpaceSlugSet()
+
+func newReservedSpaceSlugSet() map[string]struct{} {
+ slugs := make(map[string]struct{}, len(reservedSpaceSlugList))
+ for _, slug := range reservedSpaceSlugList {
+ slugs[slug] = struct{}{}
+ }
+ return slugs
+}
+
+func ValidateSpaceSlug(input string) (string, error) {
+ return validateSpaceSlug(input, false)
+}
+
+func ValidateSpaceSlugAllowReserved(input string) (string, error) {
+ return validateSpaceSlug(input, true)
+}
+
+func validateSpaceSlug(input string, allowReserved bool) (string, error) {
+ slug := normalizeSlug(input)
+ if slug == "" {
+ return "", ente.NewBadRequestWithMessage("spaceSlug is required")
+ }
+ if len(slug) < minSpaceSlugLength || len(slug) > maxSpaceSlugLength {
+ return "", ente.NewBadRequestWithMessage("spaceSlug must be 4-30 characters")
+ }
+ if !allowReserved && isReservedSpaceSlug(slug) {
+ return "", ente.NewBadRequestWithMessage("spaceSlug is reserved")
+ }
+ if !spaceSlugPattern.MatchString(slug) {
+ return "", ente.NewBadRequestWithMessage("spaceSlug can only contain lowercase letters, numbers, dots, or underscores, and must start with a letter or number")
+ }
+ return slug, nil
+}
+
+func isReservedSpaceSlug(slug string) bool {
+ if _, ok := reservedSpaceSlugs[slug]; ok {
+ return true
+ }
+ if strings.HasPrefix(slug, "ente") {
+ return true
+ }
+ return strings.HasSuffix(slug, ".ente") || strings.HasSuffix(slug, "-ente") || strings.HasSuffix(slug, "_ente")
+}
diff --git a/server/space/controller/slug_validation_test.go b/server/space/repo/slug_validation_test.go
similarity index 87%
rename from server/space/controller/slug_validation_test.go
rename to server/space/repo/slug_validation_test.go
index 887763696e..031f6086a6 100644
--- a/server/space/controller/slug_validation_test.go
+++ b/server/space/repo/slug_validation_test.go
@@ -1,4 +1,4 @@
-package controller
+package repo
import (
"strings"
@@ -21,7 +21,7 @@ func TestValidateSpaceSlugMatchesClientRules(t *testing.T) {
{name: "thirty chars", input: strings.Repeat("a", 30), normalized: strings.Repeat("a", 30)},
} {
t.Run(tc.name, func(t *testing.T) {
- normalized, err := validateSpaceSlug(tc.input)
+ normalized, err := ValidateSpaceSlug(tc.input)
require.NoError(t, err)
require.Equal(t, tc.normalized, normalized)
})
@@ -47,13 +47,31 @@ func TestValidateSpaceSlugRejectsInvalidClientSlugs(t *testing.T) {
{name: "unicode confusable", input: "paypa\u217C", message: "spaceSlug can only contain"},
} {
t.Run(tc.name, func(t *testing.T) {
- _, err := validateSpaceSlug(tc.input)
+ _, err := ValidateSpaceSlug(tc.input)
require.Error(t, err)
require.Contains(t, err.Error(), tc.message)
})
}
}
+func TestValidateSpaceSlugAllowReservedOnlyBypassesReservedCheck(t *testing.T) {
+ normalized, err := ValidateSpaceSlugAllowReserved(" Ente ")
+ require.NoError(t, err)
+ require.Equal(t, "ente", normalized)
+
+ _, err = ValidateSpaceSlugAllowReserved("ente-user")
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "spaceSlug can only contain")
+
+ _, err = ValidateSpaceSlugAllowReserved("ali/ce")
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "spaceSlug can only contain")
+
+ _, err = ValidateSpaceSlugAllowReserved("abc")
+ require.Error(t, err)
+ require.Contains(t, err.Error(), "spaceSlug must be 4-30 characters")
+}
+
func TestReservedSpaceSlugListBuildsLookup(t *testing.T) {
seen := make(map[string]struct{}, len(reservedSpaceSlugList))
for _, slug := range reservedSpaceSlugList {
@@ -145,7 +163,7 @@ func TestValidateSpaceSlugRejectsReservedSlugs(t *testing.T) {
"ente-user",
} {
t.Run(slug, func(t *testing.T) {
- _, err := validateSpaceSlug(slug)
+ _, err := ValidateSpaceSlug(slug)
require.Error(t, err)
if len(slug) < minSpaceSlugLength {
require.Contains(t, err.Error(), "spaceSlug must be 4-30 characters")
@@ -273,7 +291,7 @@ func TestValidateSpaceSlugRejectsPhishingSlugs(t *testing.T) {
"support.ente",
} {
t.Run(slug, func(t *testing.T) {
- _, err := validateSpaceSlug(slug)
+ _, err := ValidateSpaceSlug(slug)
require.Error(t, err)
if len(slug) < minSpaceSlugLength {
require.Contains(t, err.Error(), "spaceSlug must be 4-30 characters")
diff --git a/server/space/repo/spaces.go b/server/space/repo/spaces.go
index 431a98e870..f9cb0a933f 100644
--- a/server/space/repo/spaces.go
+++ b/server/space/repo/spaces.go
@@ -15,7 +15,10 @@ const MaxSpacesPerOwner = 1
var ErrSpaceOwnerLimitReached = errors.New("space owner limit reached")
func (r *SpacesRepository) CreateSpace(ctx context.Context, ownerID int64, spaceSlug string, rootWrappedSpaceKey, publicKey, encryptedSecretKey, encryptedProfile []byte, referredBySpaceID string) (*SpaceRecord, error) {
- normalizedSpaceSlug := normalizeSlug(spaceSlug)
+ normalizedSpaceSlug, err := ValidateSpaceSlug(spaceSlug)
+ if err != nil {
+ return nil, err
+ }
spaceID := base.MustNewID("space")
referredBySpaceID = strings.TrimSpace(referredBySpaceID)
tx, err := r.DB.BeginTx(ctx, nil)
@@ -199,6 +202,10 @@ func (r *SpacesRepository) UpdateProfile(ctx context.Context, spaceID string, ke
}
func (r *SpacesRepository) UpdateSlug(ctx context.Context, spaceID, spaceSlug string) (*SpaceRecord, error) {
+ normalizedSpaceSlug, err := ValidateSpaceSlug(spaceSlug)
+ if err != nil {
+ return nil, err
+ }
rec, err := scanSpaceRecord(r.DB.QueryRowContext(ctx, `
WITH updated AS (
UPDATE spaces
@@ -210,7 +217,7 @@ func (r *SpacesRepository) UpdateSlug(ctx context.Context, spaceID, spaceSlug st
FROM spaces s
JOIN updated u ON u.space_id = s.space_id
`+spaceRecordProfileAssetJoins+`
- `, normalizeSlug(spaceSlug), spaceID))
+ `, normalizedSpaceSlug, spaceID))
if err != nil {
if strings.Contains(strings.ToLower(err.Error()), "duplicate key value") {
return nil, wrapUnique(err, "space slug already exists")