Skip to content

armgit / ente

Public Imported from GitHub
0

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

Bind collection access to the authenticated app

Neeraj Guptaff4ce726830e
diff --git a/server/pkg/api/collection_app_test.go b/server/pkg/api/collection_app_test.go
new file mode 100644
index 0000000000..44039e3157
--- /dev/null
+++ b/server/pkg/api/collection_app_test.go
@@ -0,0 +1,177 @@
+package api
+
+import (
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "strconv"
+ "testing"
+ "time"
+
+ "github.com/ente/museum/ente"
+ "github.com/ente/museum/internal/testutil"
+ "github.com/ente/museum/pkg/controller/access"
+ castctrl "github.com/ente/museum/pkg/controller/cast"
+ "github.com/ente/museum/pkg/controller/collections"
+ "github.com/ente/museum/pkg/controller/public"
+ "github.com/ente/museum/pkg/controller/social"
+ "github.com/ente/museum/pkg/middleware"
+ "github.com/ente/museum/pkg/repo"
+ castrepo "github.com/ente/museum/pkg/repo/cast"
+ publicrepo "github.com/ente/museum/pkg/repo/public"
+ socialrepo "github.com/ente/museum/pkg/repo/social"
+ "github.com/ente/museum/pkg/utils/auth"
+ "github.com/gin-gonic/gin"
+ "github.com/patrickmn/go-cache"
+ "github.com/stretchr/testify/require"
+)
+
+func TestCollectionAppIsolation(t *testing.T) {
+ for _, app := range []ente.App{ente.Photos, ente.Locker} {
+ t.Run(string(app), func(t *testing.T) {
+ testutil.WithServerRoot(t)
+ db := testutil.RequireTestDB(t)
+ testutil.ResetTables(t, db)
+ _, err := db.Exec(`DELETE FROM queue WHERE queue_name = $1`, repo.TrashCollectionQueueV3)
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _, err := db.Exec(`DELETE FROM queue WHERE queue_name = $1`, repo.TrashCollectionQueueV3)
+ require.NoError(t, err)
+ testutil.ResetTables(t, db)
+ })
+ ownerID := testutil.InsertUser(t, db, testutil.UserFixture{UserID: 1, Email: "[email protected]", CreationTime: 1})
+ otherID := testutil.InsertUser(t, db, testutil.UserFixture{UserID: 2, Email: "[email protected]", CreationTime: 1})
+ linkRepo := publicrepo.NewCollectionLinkRepository(db, "")
+ collectionRepo := &repo.CollectionRepository{
+ DB: db, CollectionLinkRepo: linkRepo, QueueRepo: &repo.QueueRepository{DB: db},
+ SecretEncryptionKey: testutil.SecretEncryptionKey(),
+ }
+ castRepo := &castrepo.Repository{DB: db}
+ accessCtrl := access.NewAccessController(collectionRepo, nil)
+ owned := make(map[ente.App]int64)
+ shared := make(map[ente.App]int64)
+ for _, collectionApp := range []ente.App{ente.Photos, ente.Locker} {
+ for _, userID := range []int64{ownerID, otherID} {
+ collection, err := collectionRepo.Create(ente.Collection{
+ Owner: ente.CollectionUser{ID: userID}, App: string(collectionApp), Type: "album",
+ EncryptedKey: "key", KeyDecryptionNonce: "nonce", Name: "collection", UpdationTime: 1,
+ })
+ require.NoError(t, err)
+ if userID == ownerID {
+ owned[collectionApp] = collection.ID
+ require.NoError(t, linkRepo.Insert(t.Context(), collection.ID, string(collectionApp), 0, 0, false, false, nil))
+ code, err := castRepo.AddCode(t.Context(), "key", nil, "127.0.0.1", "device")
+ require.NoError(t, err)
+ _, err = castRepo.InsertCastData(t.Context(), ownerID, code, collection.ID, string(collectionApp), "payload")
+ require.NoError(t, err)
+ } else {
+ shared[collectionApp] = collection.ID
+ _, err = db.Exec(`INSERT INTO collection_shares(collection_id, from_user_id, to_user_id, encrypted_key, updation_time, role_type, shared_at)
+ VALUES ($1, $2, $3, 'shared-key', 1, $4, 1)`, collection.ID, otherID, ownerID, ente.VIEWER)
+ require.NoError(t, err)
+ }
+ }
+ }
+ userAuthRepo := &repo.UserAuthRepository{DB: db}
+ const token = "collection-app-test-token"
+ require.NoError(t, userAuthRepo.AddToken(ownerID, app, token, "127.0.0.1", "test"))
+ authMiddleware := &middleware.AuthMiddleware{UserAuthRepo: userAuthRepo, Cache: cache.New(time.Minute, time.Minute)}
+ collectionHandler := &CollectionHandler{Controller: &collections.CollectionController{
+ AccessCtrl: accessCtrl, CollectionRepo: collectionRepo, CastRepo: castRepo,
+ CollectionLinkCtrl: &public.CollectionLinkController{CollectionLinkRepo: linkRepo},
+ }}
+ socialHandler := &SocialHandler{Controller: &social.Controller{
+ CollectionRepo: collectionRepo,
+ CommentsRepo: &socialrepo.CommentsRepository{DB: db}, ReactionsRepo: &socialrepo.ReactionsRepository{DB: db},
+ }}
+ gin.SetMode(gin.TestMode)
+ router := gin.New()
+ storage := router.Group("/", authMiddleware.TokenAuthMiddleware(nil), middleware.RejectAuthApp())
+ storage.GET("/comments-reactions/counts", socialHandler.Counts)
+ storage.GET("/collections/:collectionID", collectionHandler.GetCollectionByID)
+ storage.DELETE("/collections/v3/:collectionID", collectionHandler.TrashV3)
+ request := func(method, path string, clientApp ente.App) *httptest.ResponseRecorder {
+ req := httptest.NewRequest(method, path, nil)
+ req.Header.Set("X-Auth-Token", token)
+ req.Header.Set("X-Client-Package", "io.ente."+string(clientApp))
+ recorder := httptest.NewRecorder()
+ router.ServeHTTP(recorder, req)
+ return recorder
+ }
+ otherApp := ente.Photos
+ if app == ente.Photos {
+ otherApp = ente.Locker
+ }
+ t.Run("counts", func(t *testing.T) {
+ response := request(http.MethodGet, "/comments-reactions/counts", app)
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ var body struct {
+ Counts []social.CollectionCount `json:"counts"`
+ }
+ require.NoError(t, json.Unmarshal(response.Body.Bytes(), &body))
+ require.ElementsMatch(t, []social.CollectionCount{{CollectionID: owned[app]}, {CollectionID: shared[app]}}, body.Counts)
+ })
+ t.Run("point_access", func(t *testing.T) {
+ for _, ids := range []map[ente.App]int64{owned, shared} {
+ for _, targetApp := range []ente.App{app, otherApp} {
+ response := request(http.MethodGet, fmt.Sprintf("/collections/%d", ids[targetApp]), app)
+ wantStatus := http.StatusForbidden
+ if targetApp == app {
+ wantStatus = http.StatusOK
+ }
+ require.Equal(t, wantStatus, response.Code, response.Body.String())
+ }
+ }
+ })
+ t.Run("cross_app_delete", func(t *testing.T) {
+ id := owned[otherApp]
+ path := fmt.Sprintf("/collections/v3/%d?collectionID=%d&keepFiles=false", id, id)
+ response := request(http.MethodDelete, path, app)
+ require.Equal(t, http.StatusForbidden, response.Code, response.Body.String())
+ response = request(http.MethodDelete, path, otherApp)
+ require.Equal(t, http.StatusUnauthorized, response.Code, response.Body.String())
+ collection, err := collectionRepo.Get(id)
+ require.NoError(t, err)
+ require.False(t, collection.IsDeleted)
+ require.Len(t, collection.PublicURLs, 1)
+ _, _, err = castRepo.GetCollectionAndCasterIDForToken(t.Context(), string(otherApp))
+ require.NoError(t, err)
+ var queued bool
+ require.NoError(t, db.QueryRow(`SELECT EXISTS (SELECT 1 FROM queue WHERE queue_name = $1 AND item = $2)`, repo.TrashCollectionQueueV3, strconv.FormatInt(id, 10)).Scan(&queued))
+ require.False(t, queued)
+ })
+ t.Run("same_app_delete", func(t *testing.T) {
+ id := owned[app]
+ response := request(http.MethodDelete, fmt.Sprintf("/collections/v3/%d?collectionID=%d&keepFiles=false", id, id), app)
+ require.Equal(t, http.StatusOK, response.Code, response.Body.String())
+ collection, err := collectionRepo.Get(id)
+ require.NoError(t, err)
+ require.True(t, collection.IsDeleted)
+ var queued bool
+ require.NoError(t, db.QueryRow(`SELECT EXISTS (SELECT 1 FROM queue WHERE queue_name = $1 AND item = $2)`, repo.TrashCollectionQueueV3, strconv.FormatInt(id, 10)).Scan(&queued))
+ require.True(t, queued)
+ })
+ t.Run("cast_access", func(t *testing.T) {
+ ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
+ ctx.Request = httptest.NewRequest(http.MethodGet, "/cast/collection", nil)
+ ctx.Request.Header.Set("X-Client-Package", "io.ente."+string(app))
+ _, present := auth.GetAuthenticatedApp(ctx)
+ require.False(t, present)
+ castCtrl := castctrl.NewController(castRepo, accessCtrl)
+ castCtx, err := castCtrl.GetCollectionAndCasterIDForToken(ctx, string(otherApp))
+ require.NoError(t, err)
+ require.Equal(t, owned[otherApp], castCtx.CollectionID)
+ require.Equal(t, ownerID, castCtx.UserID)
+ })
+ t.Run("non_member_access", func(t *testing.T) {
+ _, err := db.Exec(`DELETE FROM collection_shares WHERE to_user_id = $1`, ownerID)
+ require.NoError(t, err)
+ for _, id := range shared {
+ response := request(http.MethodGet, fmt.Sprintf("/collections/%d", id), app)
+ require.Equal(t, http.StatusNotFound, response.Code, response.Body.String())
+ }
+ })
+ })
+ }
+}
diff --git a/server/pkg/api/social.go b/server/pkg/api/social.go
index 4a8f8535ce..59512f6820 100644
--- a/server/pkg/api/social.go
+++ b/server/pkg/api/social.go
@@ -85,11 +85,12 @@ func (h *SocialHandler) UnifiedDiff(c *gin.Context) {
func (h *SocialHandler) Counts(c *gin.Context) {
userID := auth.GetUserID(c.Request.Header)
- if userID <= 0 {
+ app, ok := auth.GetAuthenticatedApp(c)
+ if userID <= 0 || !ok {
handler.Error(c, ente.ErrAuthenticationRequired)
return
}
- counts, err := h.Controller.CountActiveCollections(c, userID)
+ counts, err := h.Controller.CountActiveCollections(c, userID, app)
if err != nil {
handler.Error(c, stacktrace.Propagate(err, ""))
return
diff --git a/server/pkg/controller/access/collection.go b/server/pkg/controller/access/collection.go
index afc58aee51..cd338a88a4 100644
--- a/server/pkg/controller/access/collection.go
+++ b/server/pkg/controller/access/collection.go
@@ -2,6 +2,7 @@ package access
import (
"github.com/ente/museum/ente"
+ "github.com/ente/museum/pkg/utils/auth"
"github.com/ente/stacktrace"
"github.com/gin-gonic/gin"
)
@@ -40,6 +41,9 @@ func (c controllerImpl) GetCollection(ctx *gin.Context, req *GetCollectionParams
} else {
role = ente.OWNER
}
+ if app, ok := auth.GetAuthenticatedApp(ctx); ok && collection.App != string(app) {
+ return nil, stacktrace.Propagate(ente.ErrPermissionDenied, "collection app mismatch")
+ }
if !req.IncludeDeleted && collection.IsDeleted {
return nil, stacktrace.Propagate(ente.ErrNotFound, "trying to access deleted collection")
diff --git a/server/pkg/controller/social/controller.go b/server/pkg/controller/social/controller.go
index a098b4606e..fd55bb6450 100644
--- a/server/pkg/controller/social/controller.go
+++ b/server/pkg/controller/social/controller.go
@@ -74,7 +74,7 @@ func (c *Controller) UnifiedDiff(ctx *gin.Context, req UnifiedDiffRequest) ([]so
return comments, reactions, moreComments, moreReactions, nil
}
-func (c *Controller) CountActiveCollections(ctx context.Context, userID int64) ([]CollectionCount, error) {
+func (c *Controller) CountActiveCollections(ctx context.Context, userID int64, app ente.App) ([]CollectionCount, error) {
ownedMap, err := c.CollectionRepo.GetCollectionIDsOwnedByUser(userID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
@@ -93,6 +93,10 @@ func (c *Controller) CountActiveCollections(ctx context.Context, userID int64) (
}
collectionIDs = append(collectionIDs, id)
}
+ collectionIDs, err = c.CollectionRepo.FilterNonDeletedCollectionIDs(collectionIDs, app)
+ if err != nil {
+ return nil, stacktrace.Propagate(err, "")
+ }
if len(collectionIDs) == 0 {
return nil, nil
}