π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package controller
import (
"context"
"database/sql"
"errors"
"strings"
"github.com/ente/museum/ente"
"github.com/ente/museum/space/models"
"github.com/ente/museum/space/repo"
"github.com/ente/stacktrace"
)
const (
spaceMessageKindRegular = "regular"
spaceMessageKindPostReply = "post_reply"
spaceMessageNotificationKindPoke = "poke"
maxSpaceMessageCipherEncodedBytes = 8 * 1024
maxSpaceMessageCipherDecodedBytes = 6 * 1024
maxSpaceMessageKeyEncodedBytes = 1024
maxSpaceMessageKeyDecodedBytes = 768
spaceMessageIDPrefix = "wmsg_"
spaceMessageIDSuffixLength = 22
)
type MessagesController struct {
MessagesRepo *repo.MessagesRepository
PostsRepo *repo.PostsRepository
SpacesRepo *repo.SpacesRepository
FriendsRepo *repo.FriendsRepository
ReadMarkersRepo *repo.ReadMarkersRepository
ActivityNotifier SpaceActivityNotifier
auth authDeps
}
func (c *MessagesController) Create(ctx context.Context, senderSpace *repo.SpaceRecord, targetSpaceID string, req models.CreateMessageRequest) (*models.MessageResponse, error) {
messageCipher, senderEncryptedMessageKey, recipientEncryptedMessageKey, err := decodeCreateMessageRequest(req)
if err != nil {
return nil, err
}
notificationKind, err := normalizeMessageNotificationKind(req.NotificationKind)
if err != nil {
return nil, err
}
messageID, err := normalizeOptionalMessageID(req.MessageID)
if err != nil {
return nil, err
}
recipientSpace, err := c.requireFriendMessageTarget(ctx, senderSpace, targetSpaceID)
if err != nil {
return nil, err
}
replyMessageID, err := c.validateReplyMessage(ctx, req.ReplyMessageID, senderSpace.SpaceID, recipientSpace.SpaceID)
if err != nil {
return nil, err
}
if notificationKind == spaceMessageNotificationKindPoke && replyMessageID.Valid {
return nil, ente.NewBadRequestWithMessage("poke notification is not supported for replies")
}
message, err := c.MessagesRepo.CreateMessage(ctx, repo.CreateSpaceMessageRecord{
MessageID: messageID,
Kind: spaceMessageKindRegular,
SenderSpaceID: senderSpace.SpaceID,
RecipientSpaceID: recipientSpace.SpaceID,
MessageCipher: messageCipher,
SenderEncryptedMessageKey: senderEncryptedMessageKey,
RecipientEncryptedMessageKey: recipientEncryptedMessageKey,
ReplyMessageID: replyMessageID,
})
if err != nil {
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceMessageLimitReached) {
return nil, ente.NewConflictError("space message limit reached")
}
return nil, err
}
if notificationKind == spaceMessageNotificationKindPoke {
go c.ActivityNotifier.OnSpacePokeSent(spaceActivityActor(senderSpace), recipientSpace.OwnerID)
} else {
go c.ActivityNotifier.OnSpaceMessageSent(spaceActivityActor(senderSpace), recipientSpace.OwnerID)
}
return toMessageResponse(*message), nil
}
func (c *MessagesController) ReplyToPost(ctx context.Context, senderSpace *repo.SpaceRecord, postID int64, req models.CreateMessageRequest) (*models.MessageResponse, error) {
if strings.TrimSpace(req.NotificationKind) != "" {
return nil, ente.NewBadRequestWithMessage("notificationKind is not supported for post replies")
}
messageCipher, senderEncryptedMessageKey, recipientEncryptedMessageKey, err := decodeCreateMessageRequest(req)
if err != nil {
return nil, err
}
messageID, err := normalizeOptionalMessageID(req.MessageID)
if err != nil {
return nil, err
}
if strings.TrimSpace(req.ReplyMessageID) != "" {
return nil, ente.NewBadRequestWithMessage("replyMessageId is not supported for post replies")
}
post, err := c.PostsRepo.GetPost(ctx, postID, senderSpace.SpaceID)
if err != nil {
return nil, err
}
space, err := c.SpacesRepo.GetSpaceByID(ctx, post.SpaceID)
if err != nil {
return nil, err
}
if err := c.auth.canViewSpace(ctx, &viewerAuth{UserID: senderSpace.OwnerID, SpaceID: senderSpace.SpaceID}, space); err != nil {
return nil, err
}
if space.OwnerID == senderSpace.OwnerID {
return nil, ente.NewBadRequestWithMessage("cannot reply to your own post")
}
recipientSpace, err := c.requireFriendMessageTarget(ctx, senderSpace, space.SpaceID)
if err != nil {
return nil, err
}
message, err := c.MessagesRepo.CreateMessage(ctx, repo.CreateSpaceMessageRecord{
MessageID: messageID,
Kind: spaceMessageKindPostReply,
SenderSpaceID: senderSpace.SpaceID,
RecipientSpaceID: recipientSpace.SpaceID,
MessageCipher: messageCipher,
SenderEncryptedMessageKey: senderEncryptedMessageKey,
RecipientEncryptedMessageKey: recipientEncryptedMessageKey,
ReplyPostID: sql.NullInt64{Int64: postID, Valid: true},
})
if err != nil {
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceMessageLimitReached) {
return nil, ente.NewConflictError("space message limit reached")
}
return nil, err
}
go c.ActivityNotifier.OnSpacePostReplied(spaceActivityActor(senderSpace), recipientSpace.OwnerID)
return toMessageResponse(*message), nil
}
func (c *MessagesController) ListConversations(ctx context.Context, viewerSpace *repo.SpaceRecord) (*models.ConversationsResponse, error) {
friends, err := c.FriendsRepo.ListFriendsForSpace(ctx, viewerSpace.SpaceID)
if err != nil {
return nil, err
}
friendResponses := make([]models.SpaceFriendResponse, 0, len(friends))
friendSpaceIDs := make([]string, 0, len(friends))
for _, friend := range friends {
friendResponses = append(friendResponses, models.SpaceFriendResponse{
Friend: toActorResponse(friend.Friend, true),
ShareKeyVersion: friend.ShareKeyVersion,
CreatedAt: formatMicros(friend.CreatedAt),
})
friendSpaceIDs = append(friendSpaceIDs, friend.Friend.SpaceID)
}
summaries, err := c.MessagesRepo.ListLatestChatSummaries(ctx, viewerSpace.SpaceID, friendSpaceIDs)
if err != nil {
return nil, err
}
latestPostCreatedAt, err := c.PostsRepo.LatestPostCreatedAt(ctx, viewerSpace.SpaceID)
if err != nil {
return nil, err
}
chatSummaries := make(map[string]models.ConversationChatSummaryResponse, len(summaries))
for friendSpaceID, summary := range summaries {
unreadActivities := make([]models.MessageConversationActivityResponse, 0, len(summary.UnreadActivities))
for _, activity := range summary.UnreadActivities {
unreadActivities = append(unreadActivities, toUnreadMessageConversationActivityResponse(activity))
}
chatSummaries[friendSpaceID] = models.ConversationChatSummaryResponse{
LatestActivity: toMessageConversationActivityResponse(summary.LatestActivity),
UnreadActivities: unreadActivities,
}
}
response := &models.ConversationsResponse{
Friends: friendResponses,
ChatSummaries: chatSummaries,
}
if latestPostCreatedAt > 0 {
response.LatestPostCreatedAt = formatMicros(latestPostCreatedAt)
}
return response, nil
}
func (c *MessagesController) ListThread(ctx context.Context, viewerSpace *repo.SpaceRecord, targetSpaceID string, req models.ListMessageThreadRequest) (*models.MessagePage, error) {
if strings.TrimSpace(targetSpaceID) == "" {
return nil, ente.NewBadRequestWithMessage("spaceId is required")
}
targetSpace, err := c.SpacesRepo.GetSpaceByID(ctx, strings.TrimSpace(targetSpaceID))
if err != nil {
return nil, err
}
if err := c.auth.requireActiveSpaceOwner(ctx, targetSpace); err != nil {
return nil, err
}
if _, err := c.FriendsRepo.GetShareForFriendAndSpace(ctx, viewerSpace.SpaceID, targetSpace.SpaceID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.ErrPermissionDenied
}
return nil, err
}
messages, nextCursor, err := c.MessagesRepo.ListThread(ctx, viewerSpace.SpaceID, strings.TrimSpace(targetSpaceID), req.Cursor, req.Limit)
if err != nil {
return nil, err
}
items := make([]models.MessageResponse, 0, len(messages))
for _, message := range messages {
items = append(items, *toMessageResponse(message))
}
return &models.MessagePage{Items: items, NextCursor: nextCursor}, nil
}
func (c *MessagesController) SetLike(ctx context.Context, actorSpace *repo.SpaceRecord, messageID string, like bool) (*models.LikeMessageResponse, error) {
message, err := c.messageReactionTarget(ctx, actorSpace, messageID)
if err != nil {
return nil, err
}
otherSpaceID := message.SenderSpaceID
var recipientUserID int64
if like {
otherSpace, err := c.SpacesRepo.GetSpaceByID(ctx, otherSpaceID)
if err != nil {
return nil, err
}
recipientUserID = otherSpace.OwnerID
}
changed, err := c.MessagesRepo.SetLikeWithChanged(ctx, message.MessageID, actorSpace.SpaceID, like)
if err != nil {
return nil, err
}
if like && changed {
go c.ActivityNotifier.OnSpaceMessageLiked(spaceActivityActor(actorSpace), recipientUserID)
}
return &models.LikeMessageResponse{Liked: like}, nil
}
func (c *MessagesController) messageReactionTarget(ctx context.Context, actorSpace *repo.SpaceRecord, messageID string) (*repo.SpaceMessageRecord, error) {
messageID = strings.TrimSpace(messageID)
if messageID == "" {
return nil, ente.NewBadRequestWithMessage("messageId is required")
}
message, err := c.MessagesRepo.GetMessage(ctx, messageID, actorSpace.SpaceID)
if err != nil {
return nil, err
}
if message.IsDeleted {
return nil, ente.NewBadRequestWithMessage("cannot like a deleted message")
}
if message.Kind != spaceMessageKindRegular && message.Kind != spaceMessageKindPostReply {
return nil, ente.NewBadRequestWithMessage("cannot like this message")
}
if message.RecipientSpaceID != actorSpace.SpaceID {
return nil, ente.NewBadRequestWithMessage("only the recipient can like a message")
}
if _, err := c.FriendsRepo.GetShareForFriendAndSpace(ctx, actorSpace.SpaceID, message.SenderSpaceID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.ErrPermissionDenied
}
return nil, err
}
return message, nil
}
func (c *MessagesController) SetReaction(ctx context.Context, actorSpace *repo.SpaceRecord, messageID string, req models.SetMessageReactionRequest) (*models.LikeMessageResponse, error) {
senderCipher, err := decodeEncodedSpaceField("senderEncryptedReaction", req.SenderEncryptedReaction, 408, 304)
if err != nil {
return nil, err
}
recipientCipher, err := decodeEncodedSpaceField("recipientEncryptedReaction", req.RecipientEncryptedReaction, 408, 304)
if err != nil {
return nil, err
}
if len(senderCipher) != 304 || len(recipientCipher) != 304 {
return nil, ente.NewBadRequestWithMessage("encrypted reactions must be 304 bytes")
}
message, err := c.messageReactionTarget(ctx, actorSpace, messageID)
if err != nil {
return nil, err
}
sender, err := c.SpacesRepo.GetSpaceByID(ctx, message.SenderSpaceID)
if err != nil {
return nil, err
}
added, err := c.MessagesRepo.SetReaction(ctx, message.MessageID, actorSpace.SpaceID, senderCipher, recipientCipher)
if err != nil {
return nil, err
}
if added {
go c.ActivityNotifier.OnSpaceMessageLiked(spaceActivityActor(actorSpace), sender.OwnerID)
}
return &models.LikeMessageResponse{Liked: true}, nil
}
func (c *MessagesController) Delete(ctx context.Context, senderSpace *repo.SpaceRecord, messageID string) error {
messageID = strings.TrimSpace(messageID)
if messageID == "" {
return ente.NewBadRequestWithMessage("messageId is required")
}
message, err := c.MessagesRepo.GetMessage(ctx, messageID, senderSpace.SpaceID)
if err != nil {
return err
}
if message.SenderSpaceID != senderSpace.SpaceID {
return ente.ErrPermissionDenied
}
if message.Kind != spaceMessageKindRegular && message.Kind != spaceMessageKindPostReply {
return ente.NewBadRequestWithMessage("cannot delete this message")
}
if _, err := c.FriendsRepo.GetShareForFriendAndSpace(ctx, senderSpace.SpaceID, message.RecipientSpaceID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return ente.ErrPermissionDenied
}
return err
}
if message.IsDeleted {
return nil
}
return c.MessagesRepo.DeleteMessage(ctx, messageID, senderSpace.SpaceID)
}
func (c *MessagesController) requireFriendMessageTarget(ctx context.Context, senderSpace *repo.SpaceRecord, targetSpaceID string) (*repo.SpaceRecord, error) {
if senderSpace == nil || strings.TrimSpace(senderSpace.SpaceID) == "" {
return nil, ente.NewBadRequestWithMessage("spaceId is required")
}
targetSpaceID = strings.TrimSpace(targetSpaceID)
if targetSpaceID == "" {
return nil, ente.NewBadRequestWithMessage("spaceId is required")
}
recipientSpace, err := c.SpacesRepo.GetSpaceByID(ctx, targetSpaceID)
if err != nil {
return nil, err
}
if recipientSpace.OwnerID == senderSpace.OwnerID {
return nil, ente.NewBadRequestWithMessage("cannot message your own space")
}
if _, err := c.FriendsRepo.GetShareForFriendAndSpace(ctx, senderSpace.SpaceID, recipientSpace.SpaceID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
return nil, ente.ErrPermissionDenied
}
return nil, err
}
return recipientSpace, nil
}
func (c *MessagesController) validateReplyMessage(ctx context.Context, replyMessageID, senderSpaceID, recipientSpaceID string) (sql.NullString, error) {
replyMessageID = strings.TrimSpace(replyMessageID)
if replyMessageID == "" {
return sql.NullString{}, nil
}
parent, err := c.MessagesRepo.GetMessage(ctx, replyMessageID, senderSpaceID)
if err != nil {
return sql.NullString{}, err
}
if parent.IsDeleted {
return sql.NullString{}, ente.NewBadRequestWithMessage("cannot reply to a deleted message")
}
if !sameMessageThread(parent, senderSpaceID, recipientSpaceID) {
return sql.NullString{}, ente.ErrPermissionDenied
}
return sql.NullString{String: replyMessageID, Valid: true}, nil
}
func sameMessageThread(message *repo.SpaceMessageRecord, firstSpaceID, secondSpaceID string) bool {
return (message.SenderSpaceID == firstSpaceID && message.RecipientSpaceID == secondSpaceID) ||
(message.SenderSpaceID == secondSpaceID && message.RecipientSpaceID == firstSpaceID)
}
func normalizeOptionalMessageID(messageID string) (string, error) {
if messageID == "" {
return "", nil
}
if len(messageID) != len(spaceMessageIDPrefix)+spaceMessageIDSuffixLength || !strings.HasPrefix(messageID, spaceMessageIDPrefix) {
return "", ente.NewBadRequestWithMessage("messageId is invalid")
}
for i := len(spaceMessageIDPrefix); i < len(messageID); i++ {
c := messageID[i]
if !((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
return "", ente.NewBadRequestWithMessage("messageId is invalid")
}
}
return messageID, nil
}
func normalizeMessageNotificationKind(notificationKind string) (string, error) {
notificationKind = strings.TrimSpace(notificationKind)
if notificationKind == "" || notificationKind == spaceMessageNotificationKindPoke {
return notificationKind, nil
}
return "", ente.NewBadRequestWithMessage("notificationKind is invalid")
}
func decodeCreateMessageRequest(req models.CreateMessageRequest) ([]byte, []byte, []byte, error) {
if strings.TrimSpace(req.MessageCipher) == "" ||
strings.TrimSpace(req.SenderEncryptedMessageKey) == "" ||
strings.TrimSpace(req.RecipientEncryptedMessageKey) == "" {
return nil, nil, nil, ente.NewBadRequestWithMessage("messageCipher and encrypted message keys are required")
}
messageCipher, err := decodeEncodedSpaceField("messageCipher", req.MessageCipher, maxSpaceMessageCipherEncodedBytes, maxSpaceMessageCipherDecodedBytes)
if err != nil {
return nil, nil, nil, err
}
senderEncryptedMessageKey, err := decodeEncodedSpaceField("senderEncryptedMessageKey", req.SenderEncryptedMessageKey, maxSpaceMessageKeyEncodedBytes, maxSpaceMessageKeyDecodedBytes)
if err != nil {
return nil, nil, nil, err
}
recipientEncryptedMessageKey, err := decodeEncodedSpaceField("recipientEncryptedMessageKey", req.RecipientEncryptedMessageKey, maxSpaceMessageKeyEncodedBytes, maxSpaceMessageKeyDecodedBytes)
if err != nil {
return nil, nil, nil, err
}
return messageCipher, senderEncryptedMessageKey, recipientEncryptedMessageKey, nil
}
func toMessageResponse(message repo.SpaceMessageRecord) *models.MessageResponse {
resp := &models.MessageResponse{
MessageID: message.MessageID,
Kind: message.Kind,
SenderSpaceID: message.SenderSpaceID,
RecipientSpaceID: message.RecipientSpaceID,
MessageCipher: encodeSpaceField(message.MessageCipher),
EncryptedMessageKey: encodeSpaceField(message.EncryptedMessageKey),
EncryptedReaction: encodeSpaceField(message.EncryptedReaction),
Text: message.Text,
Liked: message.Liked,
ViewerLiked: message.ViewerLiked,
IsDeleted: message.IsDeleted,
CreatedAt: formatMicros(message.CreatedAt),
UpdatedAt: formatMicros(message.UpdatedAt),
}
if message.ReplyPostID.Valid {
replyPostID := message.ReplyPostID.Int64
resp.ReplyPostID = &replyPostID
}
if message.ReplyMessageID.Valid {
replyMessageID := message.ReplyMessageID.String
resp.ReplyMessageID = &replyMessageID
}
return resp
}
func toMessageConversationActivityMetadataResponse(activity repo.SpaceMessageConversationActivityRecord) models.MessageConversationActivityResponse {
resp := models.MessageConversationActivityResponse{
ID: activity.ID,
Type: activity.Type,
CreatedAt: formatMicros(activity.CreatedAt),
Outgoing: activity.Outgoing,
}
if activity.MessageID.Valid {
messageID := activity.MessageID.String
resp.MessageID = &messageID
}
if activity.PostID.Valid {
postID := activity.PostID.Int64
resp.PostID = &postID
if activity.PostSpaceID.Valid {
resp.PostSpaceID = activity.PostSpaceID.String
}
}
return resp
}
func toMessageConversationActivityResponse(activity repo.SpaceMessageConversationActivityRecord) models.MessageConversationActivityResponse {
resp := toMessageConversationActivityMetadataResponse(activity)
if activity.Kind.Valid {
resp.Kind = activity.Kind.String
}
if activity.SenderSpaceID.Valid {
resp.SenderSpaceID = activity.SenderSpaceID.String
}
if activity.RecipientSpaceID.Valid {
resp.RecipientSpaceID = activity.RecipientSpaceID.String
}
if len(activity.MessageCipher) > 0 {
resp.MessageCipher = encodeSpaceField(activity.MessageCipher)
}
if len(activity.EncryptedMessageKey) > 0 {
resp.EncryptedMessageKey = encodeSpaceField(activity.EncryptedMessageKey)
}
resp.EncryptedReaction = encodeSpaceField(activity.EncryptedReaction)
if activity.ReplyMessageID.Valid {
replyMessageID := activity.ReplyMessageID.String
resp.ReplyMessageID = &replyMessageID
}
return resp
}
func toUnreadMessageConversationActivityResponse(activity repo.SpaceMessageConversationActivityRecord) models.MessageConversationActivityResponse {
return toMessageConversationActivityResponse(activity)
}