nmode's Git Repositories - signal-cli/blob - lib/src/main/java/org/asamk/signal/manager/helper/StorageHelper.java

   1 package org.asamk.signal.manager.helper;
   2
   3 import org.asamk.signal.manager.SignalDependencies;
   4 import org.asamk.signal.manager.api.PhoneNumberSharingMode;
   5 import org.asamk.signal.manager.api.TrustLevel;
   6 import org.asamk.signal.manager.groups.GroupId;
   7 import org.asamk.signal.manager.storage.SignalAccount;
   8 import org.asamk.signal.manager.storage.recipients.Contact;
   9 import org.asamk.signal.manager.storage.recipients.Profile;
  10 import org.signal.libsignal.protocol.IdentityKey;
  11 import org.signal.libsignal.protocol.InvalidKeyException;
  12 import org.signal.libsignal.zkgroup.InvalidInputException;
  13 import org.signal.libsignal.zkgroup.groups.GroupMasterKey;
  14 import org.signal.libsignal.zkgroup.profiles.ProfileKey;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17 import org.whispersystems.signalservice.api.storage.SignalAccountRecord;
  18 import org.whispersystems.signalservice.api.storage.SignalStorageManifest;
  19 import org.whispersystems.signalservice.api.storage.SignalStorageRecord;
  20 import org.whispersystems.signalservice.api.storage.StorageId;
  21 import org.whispersystems.signalservice.internal.storage.protos.AccountRecord;
  22 import org.whispersystems.signalservice.internal.storage.protos.ManifestRecord;
  23
  24 import java.io.IOException;
  25 import java.util.ArrayList;
  26 import java.util.Collection;
  27 import java.util.Collections;
  28 import java.util.List;
  29 import java.util.Optional;
  30 import java.util.stream.Collectors;
  31
  32 public class StorageHelper {
  33
  34     private final static Logger logger = LoggerFactory.getLogger(StorageHelper.class);
  35
  36     private final SignalAccount account;
  37     private final SignalDependencies dependencies;
  38     private final Context context;
  39
  40     public StorageHelper(final Context context) {
  41         this.account = context.getAccount();
  42         this.dependencies = context.getDependencies();
  43         this.context = context;
  44     }
  45
  46     public void readDataFromStorage() throws IOException {
  47         final var storageKey = account.getOrCreateStorageKey();
  48         if (storageKey == null) {
  49             logger.debug("Storage key unknown, requesting from primary device.");
  50             context.getSyncHelper().requestSyncKeys();
  51             return;
  52         }
  53
  54         logger.debug("Reading data from remote storage");
  55         Optional<SignalStorageManifest> manifest;
  56         try {
  57             manifest = dependencies.getAccountManager()
  58                     .getStorageManifestIfDifferentVersion(storageKey, account.getStorageManifestVersion());
  59         } catch (InvalidKeyException e) {
  60             logger.warn("Manifest couldn't be decrypted, ignoring.");
  61             return;
  62         }
  63
  64         if (manifest.isEmpty()) {
  65             logger.debug("Manifest is up to date, does not exist or couldn't be decrypted, ignoring.");
  66             return;
  67         }
  68
  69         logger.trace("Remote storage manifest has {} records", manifest.get().getStorageIds().size());
  70         final var storageIds = manifest.get()
  71                 .getStorageIds()
  72                 .stream()
  73                 .filter(id -> !id.isUnknown())
  74                 .collect(Collectors.toSet());
  75
  76         Optional<SignalStorageManifest> localManifest = account.getStorageManifest();
  77         localManifest.ifPresent(m -> m.getStorageIds().forEach(storageIds::remove));
  78
  79         logger.trace("Reading {} new records", manifest.get().getStorageIds().size());
  80         for (final var record : getSignalStorageRecords(storageIds)) {
  81             logger.debug("Reading record of type {}", record.getType());
  82             if (record.getType() == ManifestRecord.Identifier.Type.ACCOUNT_VALUE) {
  83                 readAccountRecord(record);
  84             } else if (record.getType() == ManifestRecord.Identifier.Type.GROUPV2_VALUE) {
  85                 readGroupV2Record(record);
  86             } else if (record.getType() == ManifestRecord.Identifier.Type.GROUPV1_VALUE) {
  87                 readGroupV1Record(record);
  88             } else if (record.getType() == ManifestRecord.Identifier.Type.CONTACT_VALUE) {
  89                 readContactRecord(record);
  90             }
  91         }
  92         account.setStorageManifestVersion(manifest.get().getVersion());
  93         account.setStorageManifest(manifest.get());
  94         logger.debug("Done reading data from remote storage");
  95     }
  96
  97     private void readContactRecord(final SignalStorageRecord record) {
  98         if (record == null || record.getContact().isEmpty()) {
  99             return;
 100         }
 101
 102         final var contactRecord = record.getContact().get();
 103         final var address = contactRecord.getAddress();
 104         final var recipientId = account.getRecipientResolver().resolveRecipient(address);
 105
 106         final var contact = account.getContactStore().getContact(recipientId);
 107         final var blocked = contact != null && contact.isBlocked();
 108         final var profileShared = contact != null && contact.isProfileSharingEnabled();
 109         final var archived = contact != null && contact.isArchived();
 110         if (blocked != contactRecord.isBlocked()
 111                 || profileShared != contactRecord.isProfileSharingEnabled()
 112                 || archived != contactRecord.isArchived()) {
 113             logger.debug("Storing new or updated contact {}", recipientId);
 114             final var contactBuilder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
 115             final var newContact = contactBuilder.withBlocked(contactRecord.isBlocked())
 116                     .withProfileSharingEnabled(contactRecord.isProfileSharingEnabled())
 117                     .withArchived(contactRecord.isArchived())
 118                     .build();
 119             account.getContactStore().storeContact(recipientId, newContact);
 120         }
 121
 122         final var profile = account.getProfileStore().getProfile(recipientId);
 123         final var givenName = profile == null ? null : profile.getGivenName();
 124         final var familyName = profile == null ? null : profile.getFamilyName();
 125         if ((contactRecord.getGivenName().isPresent() && !contactRecord.getGivenName().get().equals(givenName)) || (
 126                 contactRecord.getFamilyName().isPresent() && !contactRecord.getFamilyName().get().equals(familyName)
 127         )) {
 128             final var profileBuilder = profile == null ? Profile.newBuilder() : Profile.newBuilder(profile);
 129             final var newProfile = profileBuilder.withGivenName(contactRecord.getGivenName().orElse(null))
 130                     .withFamilyName(contactRecord.getFamilyName().orElse(null))
 131                     .build();
 132             account.getProfileStore().storeProfile(recipientId, newProfile);
 133         }
 134         if (contactRecord.getProfileKey().isPresent()) {
 135             try {
 136                 logger.trace("Storing profile key {}", recipientId);
 137                 final var profileKey = new ProfileKey(contactRecord.getProfileKey().get());
 138                 account.getProfileStore().storeProfileKey(recipientId, profileKey);
 139             } catch (InvalidInputException e) {
 140                 logger.warn("Received invalid contact profile key from storage");
 141             }
 142         }
 143         if (contactRecord.getIdentityKey().isPresent()) {
 144             try {
 145                 logger.trace("Storing identity key {}", recipientId);
 146                 final var identityKey = new IdentityKey(contactRecord.getIdentityKey().get());
 147                 account.getIdentityKeyStore().saveIdentity(recipientId, identityKey);
 148
 149                 final var trustLevel = TrustLevel.fromIdentityState(contactRecord.getIdentityState());
 150                 if (trustLevel != null) {
 151                     account.getIdentityKeyStore().setIdentityTrustLevel(recipientId, identityKey, trustLevel);
 152                 }
 153             } catch (InvalidKeyException e) {
 154                 logger.warn("Received invalid contact identity key from storage");
 155             }
 156         }
 157     }
 158
 159     private void readGroupV1Record(final SignalStorageRecord record) {
 160         if (record == null || record.getGroupV1().isEmpty()) {
 161             return;
 162         }
 163
 164         final var groupV1Record = record.getGroupV1().get();
 165         final var groupIdV1 = GroupId.v1(groupV1Record.getGroupId());
 166
 167         var group = account.getGroupStore().getGroup(groupIdV1);
 168         if (group == null) {
 169             try {
 170                 context.getGroupHelper().sendGroupInfoRequest(groupIdV1, account.getSelfRecipientId());
 171             } catch (Throwable e) {
 172                 logger.warn("Failed to send group request", e);
 173             }
 174             group = account.getGroupStore().getOrCreateGroupV1(groupIdV1);
 175         }
 176         if (group != null && group.isBlocked() != groupV1Record.isBlocked()) {
 177             group.setBlocked(groupV1Record.isBlocked());
 178             account.getGroupStore().updateGroup(group);
 179         }
 180     }
 181
 182     private void readGroupV2Record(final SignalStorageRecord record) {
 183         if (record == null || record.getGroupV2().isEmpty()) {
 184             return;
 185         }
 186
 187         final var groupV2Record = record.getGroupV2().get();
 188         if (groupV2Record.isArchived()) {
 189             return;
 190         }
 191
 192         final GroupMasterKey groupMasterKey;
 193         try {
 194             groupMasterKey = new GroupMasterKey(groupV2Record.getMasterKeyBytes());
 195         } catch (InvalidInputException e) {
 196             logger.warn("Received invalid group master key from storage");
 197             return;
 198         }
 199
 200         final var group = context.getGroupHelper().getOrMigrateGroup(groupMasterKey, 0, null);
 201         if (group.isBlocked() != groupV2Record.isBlocked()) {
 202             group.setBlocked(groupV2Record.isBlocked());
 203             account.getGroupStore().updateGroup(group);
 204         }
 205     }
 206
 207     private void readAccountRecord(final SignalStorageRecord record) throws IOException {
 208         if (record == null) {
 209             logger.warn("Could not find account record, even though we had an ID, ignoring.");
 210             return;
 211         }
 212
 213         SignalAccountRecord accountRecord = record.getAccount().orElse(null);
 214         if (accountRecord == null) {
 215             logger.warn("The storage record didn't actually have an account, ignoring.");
 216             return;
 217         }
 218
 219         if (!accountRecord.getE164().equals(account.getNumber())) {
 220             context.getAccountHelper().checkWhoAmiI();
 221         }
 222
 223         account.getConfigurationStore().setReadReceipts(accountRecord.isReadReceiptsEnabled());
 224         account.getConfigurationStore().setTypingIndicators(accountRecord.isTypingIndicatorsEnabled());
 225         account.getConfigurationStore()
 226                 .setUnidentifiedDeliveryIndicators(accountRecord.isSealedSenderIndicatorsEnabled());
 227         account.getConfigurationStore().setLinkPreviews(accountRecord.isLinkPreviewsEnabled());
 228         if (accountRecord.getPhoneNumberSharingMode() != AccountRecord.PhoneNumberSharingMode.UNRECOGNIZED) {
 229             account.getConfigurationStore()
 230                     .setPhoneNumberSharingMode(switch (accountRecord.getPhoneNumberSharingMode()) {
 231                         case EVERYBODY -> PhoneNumberSharingMode.EVERYBODY;
 232                         case NOBODY -> PhoneNumberSharingMode.NOBODY;
 233                         default -> PhoneNumberSharingMode.CONTACTS;
 234                     });
 235         }
 236         account.getConfigurationStore().setPhoneNumberUnlisted(accountRecord.isPhoneNumberUnlisted());
 237
 238         if (accountRecord.getProfileKey().isPresent()) {
 239             ProfileKey profileKey;
 240             try {
 241                 profileKey = new ProfileKey(accountRecord.getProfileKey().get());
 242             } catch (InvalidInputException e) {
 243                 logger.warn("Received invalid profile key from storage");
 244                 profileKey = null;
 245             }
 246             if (profileKey != null) {
 247                 account.setProfileKey(profileKey);
 248                 final var avatarPath = accountRecord.getAvatarUrlPath().orElse(null);
 249                 context.getProfileHelper().downloadProfileAvatar(account.getSelfRecipientId(), avatarPath, profileKey);
 250             }
 251         }
 252
 253         context.getProfileHelper()
 254                 .setProfile(false,
 255                         false,
 256                         accountRecord.getGivenName().orElse(null),
 257                         accountRecord.getFamilyName().orElse(null),
 258                         null,
 259                         null,
 260                         null,
 261                         null);
 262     }
 263
 264     private SignalStorageRecord getSignalStorageRecord(final StorageId accountId) throws IOException {
 265         List<SignalStorageRecord> records;
 266         try {
 267             records = dependencies.getAccountManager()
 268                     .readStorageRecords(account.getStorageKey(), Collections.singletonList(accountId));
 269         } catch (InvalidKeyException e) {
 270             logger.warn("Failed to read storage records, ignoring.");
 271             return null;
 272         }
 273         return records.size() > 0 ? records.get(0) : null;
 274     }
 275
 276     private List<SignalStorageRecord> getSignalStorageRecords(final Collection<StorageId> storageIds) throws IOException {
 277         List<SignalStorageRecord> records;
 278         try {
 279             records = dependencies.getAccountManager()
 280                     .readStorageRecords(account.getStorageKey(), new ArrayList<>(storageIds));
 281         } catch (InvalidKeyException e) {
 282             logger.warn("Failed to read storage records, ignoring.");
 283             return List.of();
 284         }
 285         return records;
 286     }
 287 }