π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package collections
import (
"context"
"database/sql"
"errors"
"slices"
"github.com/ente/museum/ente"
"github.com/ente/museum/pkg/controller/access"
"github.com/ente/museum/pkg/controller/public"
"github.com/ente/museum/pkg/repo"
"github.com/ente/museum/pkg/utils/auth"
emailUtil "github.com/ente/museum/pkg/utils/email"
"github.com/ente/museum/pkg/utils/time"
"github.com/ente/stacktrace"
"github.com/gin-contrib/requestid"
"github.com/gin-gonic/gin"
log "github.com/sirupsen/logrus"
)
func (c *CollectionController) Share(ctx *gin.Context, req ente.AlterShareRequest) ([]ente.CollectionUser, error) {
fromUserID := auth.GetUserID(ctx.Request.Header)
if err := validateSealedCollectionKey(req.EncryptedKey); err != nil {
return nil, err
}
role := ente.VIEWER
if req.Role != nil {
role = *req.Role
}
collection, err := c.collectionForShareMutation(req.CollectionID, fromUserID)
if err != nil {
return nil, err
}
if !collection.AllowParticipantSharing(role) {
return nil, stacktrace.Propagate(ente.ErrBadRequest, "sharing %s is not allowed", collection.Type)
}
toUserID, err := c.UserLookup.LookupUserID(fromUserID, req.Email)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if err := validateShareRecipient(fromUserID, collection.Owner.ID, toUserID); err != nil {
return nil, err
}
err = c.CollectionRepo.Share(
req.CollectionID,
collection.Owner.ID,
toUserID,
req.EncryptedKey,
role,
time.Microseconds(),
)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if collection.App == string(ente.Photos) {
go c.PushCtrl.NotifyAlbumShare(ctx.Request.Context(), []int64{toUserID})
}
sharees, err := c.GetSharees(ctx, req.CollectionID, fromUserID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
return sharees, nil
}
func (c *CollectionController) BatchShare(ctx *gin.Context, shares []ente.AlterShareRequest) ([]ente.CollectionUser, error) {
if err := validateBatchShares(shares); err != nil {
return nil, err
}
fromUserID := auth.GetUserID(ctx.Request.Header)
collection, err := c.collectionForShareMutation(shares[0].CollectionID, fromUserID)
if err != nil {
return nil, err
}
if collection.IsDeleted {
return nil, stacktrace.Propagate(ente.ErrCollectionDeleted, "")
}
resolvedShares := make([]repo.CollectionShareItem, 0, len(shares))
for _, share := range shares {
if err := validateSealedCollectionKey(share.EncryptedKey); err != nil {
return nil, err
}
role := ente.VIEWER
if share.Role != nil {
role = *share.Role
}
if role != ente.VIEWER && role != ente.COLLABORATOR && role != ente.ADMIN {
return nil, ente.NewBadRequestWithMessage("invalid role " + string(role))
}
if !collection.AllowParticipantSharing(role) {
return nil, stacktrace.Propagate(ente.ErrBadRequest, "sharing %s is not allowed", collection.Type)
}
toUserID, err := c.UserLookup.LookupUserID(fromUserID, share.Email)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if err := validateShareRecipient(fromUserID, collection.Owner.ID, toUserID); err != nil {
return nil, err
}
resolvedShares = append(resolvedShares, repo.CollectionShareItem{
ToUserID: toUserID,
EncryptedKey: share.EncryptedKey,
Role: role,
})
}
err = c.CollectionRepo.BatchShare(
ctx.Request.Context(),
collection.ID,
collection.Owner.ID,
resolvedShares,
time.Microseconds(),
)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if collection.App == string(ente.Photos) {
recipients := make([]int64, len(resolvedShares))
for i, share := range resolvedShares {
recipients[i] = share.ToUserID
}
go c.PushCtrl.NotifyAlbumShare(ctx.Request.Context(), recipients)
}
sharees, err := c.GetSharees(ctx, collection.ID, fromUserID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
return sharees, nil
}
func validateBatchShares(shares []ente.AlterShareRequest) error {
if len(shares) == 0 {
return stacktrace.Propagate(ente.ErrBadRequest, "shares are required")
}
if len(shares) > ente.MaxBatchShareSize {
return stacktrace.Propagate(ente.ErrBatchSizeTooLarge, "")
}
collectionID := shares[0].CollectionID
seen := make(map[string]struct{}, len(shares))
for _, share := range shares {
if share.CollectionID != collectionID {
return stacktrace.Propagate(ente.ErrBadRequest, "all shares must have the same collection ID")
}
email := emailUtil.NormalizeEmail(share.Email)
if email == "" {
return stacktrace.Propagate(ente.ErrBadRequest, "email is required")
}
if _, ok := seen[email]; ok {
return stacktrace.Propagate(ente.ErrBadRequest, "duplicate email")
}
seen[email] = struct{}{}
}
return nil
}
func (c *CollectionController) BulkShare(
ctx *gin.Context,
req ente.BulkCollectionShareRequest,
) ([]ente.BulkCollectionShareResult, error) {
if err := validateCollectionShareBatch(req.Collections, req.Source); err != nil {
return nil, err
}
fromUserID := auth.GetUserID(ctx.Request.Header)
if err := validateBulkShareRecipient(fromUserID, req.RecipientUserID); err != nil {
return nil, err
}
if err := c.UserLookup.VerifyUserID(
fromUserID,
req.RecipientEmail,
req.RecipientUserID,
); err != nil {
return nil, stacktrace.Propagate(err, "")
}
if req.Source == ente.AutomaticShare {
sameFamily, err := c.UserRepo.AreUsersInSameFamily(
ctx.Request.Context(),
fromUserID,
req.RecipientUserID,
)
if err != nil {
return nil, err
}
if !sameFamily {
return nil, stacktrace.Propagate(ente.ErrAutomaticShareRecipientNotEligible, "")
}
}
notify := false
results := make([]ente.BulkCollectionShareResult, 0, len(req.Collections))
for _, item := range req.Collections {
status, shouldNotify, err := c.shareCollectionWithUserID(
ctx,
fromUserID,
req.RecipientUserID,
req.Source,
item,
)
if err != nil {
log.WithError(err).WithFields(log.Fields{
"collection_id": item.CollectionID,
"from_user_id": fromUserID,
"recipient_user_id": req.RecipientUserID,
}).Warn("bulk collection share failed")
status = ente.CollectionShareOperationFailed
}
notify = notify || (err == nil && shouldNotify)
results = append(results, ente.BulkCollectionShareResult{
CollectionID: item.CollectionID,
Status: status,
})
}
if notify {
go c.PushCtrl.NotifyAlbumShare(ctx.Request.Context(), []int64{req.RecipientUserID})
}
return results, nil
}
func validateBulkShareRecipient(actorUserID, recipientUserID int64) error {
if recipientUserID <= 0 {
return stacktrace.Propagate(ente.ErrBadRequest, "invalid recipient user ID")
}
if actorUserID == recipientUserID {
return stacktrace.Propagate(ente.ErrBadRequest, "Can not share collections with self")
}
return nil
}
func (c *CollectionController) shareCollectionWithUserID(
ctx context.Context,
fromUserID int64,
toUserID int64,
source ente.CollectionShareSource,
item ente.BulkCollectionShareItem,
) (ente.CollectionShareStatus, bool, error) {
if err := validateSealedCollectionKey(item.EncryptedKey); err != nil {
return "", false, err
}
collection, err := c.collectionForShareMutation(item.CollectionID, fromUserID)
if err != nil {
return "", false, err
}
if source == ente.AutomaticShare && fromUserID != collection.Owner.ID {
return "", false, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
if !collection.AllowParticipantSharing(item.Role) {
return "", false, stacktrace.Propagate(
ente.ErrBadRequest,
"sharing %s as %s is not allowed",
collection.Type,
item.Role,
)
}
if err := validateShareRecipient(fromUserID, collection.Owner.ID, toUserID); err != nil {
return "", false, err
}
updationTime := time.Microseconds()
if source == ente.ManualShare {
err := c.CollectionRepo.Share(
item.CollectionID,
collection.Owner.ID,
toUserID,
item.EncryptedKey,
item.Role,
updationTime,
)
return ente.CollectionShared, collection.App == string(ente.Photos), err
}
status, err := c.CollectionRepo.ShareAutomatically(
ctx,
item.CollectionID,
collection.Owner.ID,
toUserID,
item.EncryptedKey,
item.Role,
updationTime,
)
return status, false, err
}
func (c *CollectionController) collectionForShareMutation(
collectionID int64,
actorUserID int64,
) (ente.Collection, error) {
collection, err := c.CollectionRepo.Get(collectionID)
if err != nil {
return ente.Collection{}, stacktrace.Propagate(err, "")
}
if actorUserID == collection.Owner.ID {
return collection, nil
}
shareeRole, err := c.CollectionRepo.GetCollectionShareeRole(collectionID, actorUserID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return ente.Collection{}, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
return ente.Collection{}, stacktrace.Propagate(err, "")
}
if shareeRole == nil || *shareeRole != ente.ADMIN {
return ente.Collection{}, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
return collection, nil
}
func validateShareRecipient(actorUserID, ownerUserID, recipientUserID int64) error {
if recipientUserID == actorUserID {
return stacktrace.Propagate(ente.ErrBadRequest, "Can not share collection with self")
}
if recipientUserID == ownerUserID {
return stacktrace.Propagate(ente.ErrBadRequest, "Can not share collection with owner")
}
return nil
}
func validateCollectionShareBatch(
items []ente.BulkCollectionShareItem,
source ente.CollectionShareSource,
) error {
if !source.IsValid() || len(items) == 0 {
return stacktrace.Propagate(ente.ErrBadRequest, "")
}
if len(items) > ente.MaxCollectionShareBatchSize {
return stacktrace.Propagate(ente.ErrBatchSizeTooLarge, "")
}
seen := make(map[int64]struct{}, len(items))
for _, item := range items {
if _, exists := seen[item.CollectionID]; exists {
return stacktrace.Propagate(ente.ErrBadRequest, "duplicate collection ID %d", item.CollectionID)
}
seen[item.CollectionID] = struct{}{}
}
return nil
}
func (c *CollectionController) JoinViaLink(ctx *gin.Context, req ente.JoinCollectionViaLinkRequest) error {
if err := validateSealedCollectionKey(req.EncryptedKey); err != nil {
return err
}
userID := auth.GetUserID(ctx.Request.Header)
collection, err := c.CollectionRepo.Get(req.CollectionID)
if err != nil {
return stacktrace.Propagate(err, "")
}
if collection.Owner.ID == userID {
return stacktrace.Propagate(ente.ErrBadRequest, "owner can not join via link")
}
if !collection.AllowSharing() {
return stacktrace.Propagate(ente.ErrBadRequest, "joining %s is not allowed", collection.Type)
}
collectionLinkToken, err := c.CollectionLinkCtrl.GetActiveCollectionLinkToken(ctx, req.CollectionID)
if err != nil {
return stacktrace.Propagate(err, "")
}
if canJoin := collectionLinkToken.CanJoin(); canJoin != nil {
return stacktrace.Propagate(ente.ErrBadRequest, "can not join collection: %s", canJoin.Error())
}
accessToken := auth.GetAccessToken(ctx)
if collectionLinkToken.Token != accessToken {
return stacktrace.Propagate(ente.ErrPermissionDenied, "token doesn't match collection")
}
if collectionLinkToken.PassHash != nil && *collectionLinkToken.PassHash != "" {
accessTokenJWT := auth.GetAccessTokenJWT(ctx)
if passCheckErr := c.CollectionLinkCtrl.ValidateJWTToken(ctx, accessTokenJWT, *collectionLinkToken.PassHash); passCheckErr != nil {
return stacktrace.Propagate(passCheckErr, "")
}
}
err = c.BillingCtrl.HasActiveSelfOrFamilySubscription(collection.Owner.ID, true)
if err != nil {
if !errors.Is(err, ente.ErrSharingDisabledForFreeAccounts) {
return stacktrace.Propagate(err, "")
}
}
role := ente.VIEWER
if collectionLinkToken.EnableCollect {
role = ente.COLLABORATOR
}
joinErr := c.CollectionRepo.Share(req.CollectionID, collection.Owner.ID, userID, req.EncryptedKey, role, time.Microseconds())
if joinErr != nil {
return stacktrace.Propagate(joinErr, "")
}
go c.EmailCtrl.OnLinkJoined(collection.Owner.ID, userID, role)
return nil
}
func (c *CollectionController) UnShare(ctx *gin.Context, cID int64, fromUserID int64, toUserEmail string) ([]ente.CollectionUser, error) {
collection, err := c.collectionForShareMutation(cID, fromUserID)
if err != nil {
return nil, err
}
sharees, err := c.CollectionRepo.GetSharees(cID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
toUserIndex := shareeIndexForEmail(sharees, toUserEmail)
if toUserIndex == -1 {
return nil, stacktrace.Propagate(ente.ErrNotFound, "")
}
toUserID := sharees[toUserIndex].ID
if toUserID == fromUserID || toUserID == collection.Owner.ID {
return nil, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
err = c.CollectionRepo.UnShare(cID, toUserID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
if err := c.cleanupRevokedShare(ctx, cID, toUserID); err != nil {
return nil, err
}
return slices.Delete(sharees, toUserIndex, toUserIndex+1), nil
}
func (c *CollectionController) BulkUnShare(
ctx *gin.Context,
req ente.BulkCollectionUnshareRequest,
) ([]ente.BulkCollectionShareResult, error) {
// Source is request-scoped; share provenance is not persisted.
// Automatic callers must exclude shares that should be preserved.
if err := validateCollectionUnshareBatch(req.CollectionIDs, req.Source); err != nil {
return nil, err
}
fromUserID := auth.GetUserID(ctx.Request.Header)
if err := validateBulkShareRecipient(fromUserID, req.RecipientUserID); err != nil {
return nil, err
}
results := make([]ente.BulkCollectionShareResult, 0, len(req.CollectionIDs))
for _, collectionID := range req.CollectionIDs {
status, err := c.unshareCollectionWithUserID(
ctx,
collectionID,
fromUserID,
req.RecipientUserID,
req.Source,
)
if err != nil {
log.WithError(err).WithFields(log.Fields{
"collection_id": collectionID,
"from_user_id": fromUserID,
"recipient_user_id": req.RecipientUserID,
}).Warn("bulk collection unshare failed")
status = ente.CollectionShareOperationFailed
}
results = append(results, ente.BulkCollectionShareResult{
CollectionID: collectionID,
Status: status,
})
}
return results, nil
}
func (c *CollectionController) unshareCollectionWithUserID(
ctx context.Context,
collectionID int64,
fromUserID int64,
toUserID int64,
source ente.CollectionShareSource,
) (ente.CollectionShareStatus, error) {
collection, err := c.collectionForShareMutation(collectionID, fromUserID)
if err != nil {
return "", err
}
if source == ente.AutomaticShare && fromUserID != collection.Owner.ID {
return "", stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
if err := validateShareRecipient(fromUserID, collection.Owner.ID, toUserID); err != nil {
return "", err
}
status, err := c.CollectionRepo.UnShareContext(ctx, collectionID, toUserID)
if err != nil {
return "", stacktrace.Propagate(err, "")
}
if status == ente.CollectionNotShared {
return status, nil
}
if err := c.cleanupRevokedShare(ctx, collectionID, toUserID); err != nil {
return "", err
}
return status, nil
}
func (c *CollectionController) cleanupRevokedShare(
ctx context.Context,
collectionID int64,
userID int64,
) error {
if err := c.removeUserSocialActivity(ctx, collectionID, userID); err != nil {
return err
}
if err := c.CastRepo.RevokeForGivenUserAndCollection(ctx, collectionID, userID); err != nil {
return stacktrace.Propagate(err, "")
}
return nil
}
func validateCollectionUnshareBatch(
collectionIDs []int64,
source ente.CollectionShareSource,
) error {
if !source.IsValid() || len(collectionIDs) == 0 {
return stacktrace.Propagate(ente.ErrBadRequest, "")
}
if len(collectionIDs) > ente.MaxCollectionShareBatchSize {
return stacktrace.Propagate(ente.ErrBatchSizeTooLarge, "")
}
seen := make(map[int64]struct{}, len(collectionIDs))
for _, collectionID := range collectionIDs {
if _, exists := seen[collectionID]; exists {
return stacktrace.Propagate(ente.ErrBadRequest, "duplicate collection ID %d", collectionID)
}
seen[collectionID] = struct{}{}
}
return nil
}
func shareeIndexForEmail(sharees []ente.CollectionUser, targetEmail string) int {
targetEmail = emailUtil.NormalizeEmail(targetEmail)
return slices.IndexFunc(sharees, func(sharee ente.CollectionUser) bool {
return emailUtil.NormalizeEmail(sharee.Email) == targetEmail
})
}
func (c *CollectionController) Leave(ctx *gin.Context, cID int64) error {
userID := auth.GetUserID(ctx.Request.Header)
collection, err := c.CollectionRepo.Get(cID)
if err != nil {
return stacktrace.Propagate(err, "")
}
if userID == collection.Owner.ID {
return stacktrace.Propagate(ente.ErrPermissionDenied, "can not leave collection owned by self")
}
sharedCollectionIDs, err := c.CollectionRepo.GetCollectionIDsSharedWithUser(userID)
if err != nil {
return stacktrace.Propagate(err, "")
}
if !slices.Contains(sharedCollectionIDs, cID) {
return nil
}
err = c.CastRepo.RevokeForGivenUserAndCollection(ctx, cID, userID)
if err != nil {
return stacktrace.Propagate(err, "")
}
err = c.CollectionRepo.UnShare(cID, userID)
if err != nil {
return stacktrace.Propagate(err, "")
}
if err := c.removeUserSocialActivity(ctx, cID, userID); err != nil {
return err
}
return nil
}
func (c *CollectionController) UpdateShareeMagicMetadata(ctx *gin.Context, req ente.UpdateCollectionMagicMetadata) error {
actorUserId := auth.GetUserID(ctx.Request.Header)
resp, err := c.AccessCtrl.GetCollection(ctx, &access.GetCollectionParams{
CollectionID: req.ID,
ActorUserID: actorUserId,
})
if err != nil {
return stacktrace.Propagate(err, "")
}
if resp.Collection.Owner.ID == actorUserId {
return stacktrace.Propagate(ente.NewBadRequestWithMessage("owner can not update sharee magic metadata"), "")
}
err = c.CollectionRepo.UpdateShareeMetadata(req.ID, resp.Collection.Owner.ID, actorUserId, req.MagicMetadata, time.Microseconds())
if err != nil {
return stacktrace.Propagate(err, "failed to update sharee magic metadata")
}
return nil
}
func (c *CollectionController) ShareURL(ctx *gin.Context, userID int64, req ente.CreatePublicAccessTokenRequest) (
ente.PublicURL, error) {
if err := req.Validate(); err != nil {
return ente.PublicURL{}, stacktrace.Propagate(err, "")
}
collection, err := c.CollectionRepo.Get(req.CollectionID)
if err != nil {
return ente.PublicURL{}, stacktrace.Propagate(err, "")
}
if !collection.AllowSharing() {
return ente.PublicURL{}, stacktrace.Propagate(ente.ErrBadRequest, "sharing %s is not allowed", collection.Type)
}
if userID != collection.Owner.ID {
return ente.PublicURL{}, stacktrace.Propagate(ente.ErrPermissionDenied, "")
}
valTrue := true
if req.EnableJoin == nil {
req.EnableJoin = &valTrue
}
err = c.BillingCtrl.HasActiveSelfOrFamilySubscription(userID, true)
if err != nil {
if !errors.Is(err, ente.ErrSharingDisabledForFreeAccounts) {
return ente.PublicURL{}, stacktrace.Propagate(err, "")
}
req.DeviceLimit = public.FreeUserDeviceLimit
}
response, err := c.CollectionLinkCtrl.CreateLink(ctx, req)
if err != nil {
return ente.PublicURL{}, stacktrace.Propagate(err, "")
}
return response, nil
}
func (c *CollectionController) UpdateShareURL(
ctx *gin.Context,
userID int64,
req ente.UpdatePublicAccessTokenRequest,
) (*ente.PublicURL, error) {
if err := req.Validate(); err != nil {
return nil, stacktrace.Propagate(err, "")
}
if err := c.verifyOwnership(req.CollectionID, userID); err != nil {
return nil, stacktrace.Propagate(err, "")
}
err := c.BillingCtrl.HasActiveSelfOrFamilySubscription(userID, true)
if err != nil {
if errors.Is(err, ente.ErrSharingDisabledForFreeAccounts) {
if req.DeviceLimit != nil && !public.IsAllowedFreeUserDeviceLimit(*req.DeviceLimit) {
return nil, stacktrace.Propagate(&ente.ErrLinkEditNotAllowed, "")
}
} else {
return nil, stacktrace.Propagate(err, "")
}
}
response, err := c.CollectionLinkCtrl.UpdateSharedUrl(ctx, req)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
return &response, nil
}
func (c *CollectionController) DisableSharedURL(ctx context.Context, userID int64, cID int64) error {
if err := c.verifyOwnership(cID, userID); err != nil {
return stacktrace.Propagate(err, "")
}
err := c.CollectionLinkCtrl.Disable(ctx, cID)
return stacktrace.Propagate(err, "")
}
func (c *CollectionController) GetSharees(ctx *gin.Context, cID int64, userID int64) ([]ente.CollectionUser, error) {
_, err := c.AccessCtrl.GetCollection(ctx, &access.GetCollectionParams{
CollectionID: cID,
ActorUserID: userID,
})
if err != nil {
return nil, stacktrace.Propagate(err, "Access check failed")
}
sharees, err := c.CollectionRepo.GetSharees(cID)
if err != nil {
return nil, stacktrace.Propagate(err, "")
}
return sharees, nil
}
func (c *CollectionController) GetPublicDiff(ctx *gin.Context, sinceTime int64) ([]ente.File, bool, error) {
accessContext := auth.MustGetPublicAccessContext(ctx)
reqContextLogger := log.WithFields(log.Fields{
"public_id": accessContext.ID,
"collection_id": accessContext.CollectionID,
"since_time": sinceTime,
"req_id": requestid.Get(ctx),
})
diff, hasMore, err := c.getDiff(accessContext.CollectionID, sinceTime, CollectionDiffLimit, reqContextLogger)
if err != nil {
return nil, false, stacktrace.Propagate(err, "")
}
// Don't expose private metadata in a public diff.
for idx := range diff {
if diff[idx].MagicMetadata != nil {
diff[idx].MagicMetadata = nil
}
// For public diffs, treat action markers as deleted and strip action details
if diff[idx].Action != nil && !diff[idx].IsDeleted {
if *diff[idx].Action == ente.ActionRemove || *diff[idx].Action == ente.ActionDeleteSuggested {
diff[idx].IsDeleted = true
}
}
diff[idx].Action = nil
diff[idx].ActionUserID = nil
if diff[idx].Metadata.EncryptedData == "-" && !diff[idx].IsDeleted {
// "-" marks a deleted file whose collection entry is stale.
reqContextLogger.WithFields(log.Fields{
"file_id": diff[idx].ID,
"updated_at": diff[idx].UpdationTime,
}).Warning("stale collection_file found")
diff[idx].IsDeleted = true
}
}
scrubDeletedFiles(diff)
return diff, hasMore, nil
}