status-im/status-go

package communities

import (
    "go.uber.org/zap"

    "github.com/status-im/status-go/eth-node/types"
    "github.com/status-im/status-go/protocol/protobuf"
)

type DescriptionEncryptor interface {
    encryptCommunityDescription(community *Community, d *protobuf.CommunityDescription) (string, []byte, error)
    encryptCommunityDescriptionChannel(community *Community, channelID string, d *protobuf.CommunityDescription) (string, []byte, error)
    decryptCommunityDescription(keyIDSeqNo string, d []byte) (*DecryptCommunityResponse, error)
}

// Encrypts members and chats
func encryptDescription(encryptor DescriptionEncryptor, community *Community, description *protobuf.CommunityDescription) error {
    description.PrivateData = make(map[string][]byte)

    for channelID, channel := range description.Chats {
        if !community.channelEncrypted(channelID) {
            continue
        }

        descriptionToEncrypt := &protobuf.CommunityDescription{
            Chats: map[string]*protobuf.CommunityChat{
                channelID: channel,
            },
        }

        keyIDSeqNo, encryptedDescription, err := encryptor.encryptCommunityDescriptionChannel(community, channelID, descriptionToEncrypt)
        if err != nil {
            return err
        }

        // Set private data and cleanup unencrypted channel's members
        description.PrivateData[keyIDSeqNo] = encryptedDescription
        channel.Members = make(map[string]*protobuf.CommunityMember)
    }

    if community.Encrypted() {
        descriptionToEncrypt := &protobuf.CommunityDescription{
            Members:            description.Members,
            ActiveMembersCount: description.ActiveMembersCount,
            Chats:              description.Chats,
            Categories:         description.Categories,
        }

        keyIDSeqNo, encryptedDescription, err := encryptor.encryptCommunityDescription(community, descriptionToEncrypt)
        if err != nil {
            return err
        }

        // Set private data and cleanup unencrypted members, chats and categories
        description.PrivateData[keyIDSeqNo] = encryptedDescription
        description.Members = make(map[string]*protobuf.CommunityMember)
        description.ActiveMembersCount = 0
        description.Chats = make(map[string]*protobuf.CommunityChat)
        description.Categories = make(map[string]*protobuf.CommunityCategory)
    }

    return nil
}

type CommunityPrivateDataFailedToDecrypt struct {
    GroupID []byte
    KeyID   []byte
}

// Decrypts members and chats
func decryptDescription(id types.HexBytes, encryptor DescriptionEncryptor, description *protobuf.CommunityDescription, logger *zap.Logger) ([]*CommunityPrivateDataFailedToDecrypt, error) {
    if len(description.PrivateData) == 0 {
        return nil, nil
    }

    var failedToDecrypt []*CommunityPrivateDataFailedToDecrypt

    for keyIDSeqNo, encryptedDescription := range description.PrivateData {
        decryptedDescriptionResponse, err := encryptor.decryptCommunityDescription(keyIDSeqNo, encryptedDescription)
        if decryptedDescriptionResponse != nil && !decryptedDescriptionResponse.Decrypted {
            failedToDecrypt = append(failedToDecrypt, &CommunityPrivateDataFailedToDecrypt{GroupID: id, KeyID: decryptedDescriptionResponse.KeyID})
        }
        if err != nil {
            // ignore error, try to decrypt next data
            logger.Debug("failed to decrypt community private data", zap.String("keyIDSeqNo", keyIDSeqNo), zap.Error(err))
            continue
        }
        decryptedDescription := decryptedDescriptionResponse.Description

        if len(decryptedDescription.Members) > 0 {
            description.Members = decryptedDescription.Members
        }

        if decryptedDescription.ActiveMembersCount > 0 {
            description.ActiveMembersCount = decryptedDescription.ActiveMembersCount
        }

        for id, decryptedChannel := range decryptedDescription.Chats {
            if description.Chats == nil {
                description.Chats = make(map[string]*protobuf.CommunityChat)
            }

            if channel := description.Chats[id]; channel != nil {
                if len(decryptedChannel.Members) > 0 {
                    channel.Members = decryptedChannel.Members
                }
            } else {
                description.Chats[id] = decryptedChannel
            }
        }

        if len(decryptedDescription.Categories) > 0 {
            description.Categories = decryptedDescription.Categories
        }
    }

    return failedToDecrypt, nil
}