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

   1 package org.asamk.signal.manager.helper;
   2
   3 import org.asamk.signal.manager.TrustLevel;
   4 import org.asamk.signal.manager.storage.SignalAccount;
   5 import org.asamk.signal.manager.storage.groups.GroupInfoV1;
   6 import org.asamk.signal.manager.storage.recipients.Contact;
   7 import org.asamk.signal.manager.util.AttachmentUtils;
   8 import org.asamk.signal.manager.util.IOUtils;
   9 import org.slf4j.Logger;
  10 import org.slf4j.LoggerFactory;
  11 import org.whispersystems.libsignal.IdentityKey;
  12 import org.whispersystems.libsignal.util.guava.Optional;
  13 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
  14 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentStream;
  15 import org.whispersystems.signalservice.api.messages.multidevice.BlockedListMessage;
  16 import org.whispersystems.signalservice.api.messages.multidevice.ConfigurationMessage;
  17 import org.whispersystems.signalservice.api.messages.multidevice.ContactsMessage;
  18 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContact;
  19 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsInputStream;
  20 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsOutputStream;
  21 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroup;
  22 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsOutputStream;
  23 import org.whispersystems.signalservice.api.messages.multidevice.KeysMessage;
  24 import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage;
  25 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
  26 import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage;
  27 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  28 import org.whispersystems.signalservice.internal.push.SignalServiceProtos;
  29
  30 import java.io.FileInputStream;
  31 import java.io.FileOutputStream;
  32 import java.io.IOException;
  33 import java.io.InputStream;
  34 import java.io.OutputStream;
  35 import java.nio.file.Files;
  36 import java.util.ArrayList;
  37
  38 public class SyncHelper {
  39
  40     private final static Logger logger = LoggerFactory.getLogger(SyncHelper.class);
  41
  42     private final Context context;
  43     private final SignalAccount account;
  44
  45     public SyncHelper(final Context context) {
  46         this.context = context;
  47         this.account = context.getAccount();
  48     }
  49
  50     public void requestAllSyncData() {
  51         requestSyncGroups();
  52         requestSyncContacts();
  53         requestSyncBlocked();
  54         requestSyncConfiguration();
  55         requestSyncKeys();
  56     }
  57
  58     public void sendSyncFetchProfileMessage() {
  59         context.getSendHelper()
  60                 .sendSyncMessage(SignalServiceSyncMessage.forFetchLatest(SignalServiceSyncMessage.FetchType.LOCAL_PROFILE));
  61     }
  62
  63     public void sendGroups() throws IOException {
  64         var groupsFile = IOUtils.createTempFile();
  65
  66         try {
  67             try (OutputStream fos = new FileOutputStream(groupsFile)) {
  68                 var out = new DeviceGroupsOutputStream(fos);
  69                 for (var record : account.getGroupStore().getGroups()) {
  70                     if (record instanceof GroupInfoV1 groupInfo) {
  71                         out.write(new DeviceGroup(groupInfo.getGroupId().serialize(),
  72                                 Optional.fromNullable(groupInfo.name),
  73                                 groupInfo.getMembers()
  74                                         .stream()
  75                                         .map(context.getRecipientHelper()::resolveSignalServiceAddress)
  76                                         .toList(),
  77                                 context.getGroupHelper().createGroupAvatarAttachment(groupInfo.getGroupId()),
  78                                 groupInfo.isMember(account.getSelfRecipientId()),
  79                                 Optional.of(groupInfo.messageExpirationTime),
  80                                 Optional.fromNullable(groupInfo.color),
  81                                 groupInfo.blocked,
  82                                 Optional.absent(),
  83                                 groupInfo.archived));
  84                     }
  85                 }
  86             }
  87
  88             if (groupsFile.exists() && groupsFile.length() > 0) {
  89                 try (var groupsFileStream = new FileInputStream(groupsFile)) {
  90                     var attachmentStream = SignalServiceAttachment.newStreamBuilder()
  91                             .withStream(groupsFileStream)
  92                             .withContentType("application/octet-stream")
  93                             .withLength(groupsFile.length())
  94                             .build();
  95
  96                     context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
  97                 }
  98             }
  99         } finally {
 100             try {
 101                 Files.delete(groupsFile.toPath());
 102             } catch (IOException e) {
 103                 logger.warn("Failed to delete groups temp file “{}”, ignoring: {}", groupsFile, e.getMessage());
 104             }
 105         }
 106     }
 107
 108     public void sendContacts() throws IOException {
 109         var contactsFile = IOUtils.createTempFile();
 110
 111         try {
 112             try (OutputStream fos = new FileOutputStream(contactsFile)) {
 113                 var out = new DeviceContactsOutputStream(fos);
 114                 for (var contactPair : account.getContactStore().getContacts()) {
 115                     final var recipientId = contactPair.first();
 116                     final var contact = contactPair.second();
 117                     final var address = context.getRecipientHelper().resolveSignalServiceAddress(recipientId);
 118
 119                     var currentIdentity = account.getIdentityKeyStore().getIdentity(recipientId);
 120                     VerifiedMessage verifiedMessage = null;
 121                     if (currentIdentity != null) {
 122                         verifiedMessage = new VerifiedMessage(address,
 123                                 currentIdentity.getIdentityKey(),
 124                                 currentIdentity.getTrustLevel().toVerifiedState(),
 125                                 currentIdentity.getDateAdded().getTime());
 126                     }
 127
 128                     var profileKey = account.getProfileStore().getProfileKey(recipientId);
 129                     out.write(new DeviceContact(address,
 130                             Optional.fromNullable(contact.getName()),
 131                             createContactAvatarAttachment(address),
 132                             Optional.fromNullable(contact.getColor()),
 133                             Optional.fromNullable(verifiedMessage),
 134                             Optional.fromNullable(profileKey),
 135                             contact.isBlocked(),
 136                             Optional.of(contact.getMessageExpirationTime()),
 137                             Optional.absent(),
 138                             contact.isArchived()));
 139                 }
 140
 141                 if (account.getProfileKey() != null) {
 142                     // Send our own profile key as well
 143                     out.write(new DeviceContact(account.getSelfAddress(),
 144                             Optional.absent(),
 145                             Optional.absent(),
 146                             Optional.absent(),
 147                             Optional.absent(),
 148                             Optional.of(account.getProfileKey()),
 149                             false,
 150                             Optional.absent(),
 151                             Optional.absent(),
 152                             false));
 153                 }
 154             }
 155
 156             if (contactsFile.exists() && contactsFile.length() > 0) {
 157                 try (var contactsFileStream = new FileInputStream(contactsFile)) {
 158                     var attachmentStream = SignalServiceAttachment.newStreamBuilder()
 159                             .withStream(contactsFileStream)
 160                             .withContentType("application/octet-stream")
 161                             .withLength(contactsFile.length())
 162                             .build();
 163
 164                     context.getSendHelper()
 165                             .sendSyncMessage(SignalServiceSyncMessage.forContacts(new ContactsMessage(attachmentStream,
 166                                     true)));
 167                 }
 168             }
 169         } finally {
 170             try {
 171                 Files.delete(contactsFile.toPath());
 172             } catch (IOException e) {
 173                 logger.warn("Failed to delete contacts temp file “{}”, ignoring: {}", contactsFile, e.getMessage());
 174             }
 175         }
 176     }
 177
 178     public void sendBlockedList() {
 179         var addresses = new ArrayList<SignalServiceAddress>();
 180         for (var record : account.getContactStore().getContacts()) {
 181             if (record.second().isBlocked()) {
 182                 addresses.add(context.getRecipientHelper().resolveSignalServiceAddress(record.first()));
 183             }
 184         }
 185         var groupIds = new ArrayList<byte[]>();
 186         for (var record : account.getGroupStore().getGroups()) {
 187             if (record.isBlocked()) {
 188                 groupIds.add(record.getGroupId().serialize());
 189             }
 190         }
 191         context.getSendHelper()
 192                 .sendSyncMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds)));
 193     }
 194
 195     public void sendVerifiedMessage(
 196             SignalServiceAddress destination, IdentityKey identityKey, TrustLevel trustLevel
 197     ) throws IOException {
 198         var verifiedMessage = new VerifiedMessage(destination,
 199                 identityKey,
 200                 trustLevel.toVerifiedState(),
 201                 System.currentTimeMillis());
 202         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
 203     }
 204
 205     public void sendKeysMessage() {
 206         var keysMessage = new KeysMessage(Optional.fromNullable(account.getStorageKey()));
 207         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forKeys(keysMessage));
 208     }
 209
 210     public void sendConfigurationMessage() {
 211         final var config = account.getConfigurationStore();
 212         var configurationMessage = new ConfigurationMessage(Optional.fromNullable(config.getReadReceipts()),
 213                 Optional.fromNullable(config.getUnidentifiedDeliveryIndicators()),
 214                 Optional.fromNullable(config.getTypingIndicators()),
 215                 Optional.fromNullable(config.getLinkPreviews()));
 216         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forConfiguration(configurationMessage));
 217     }
 218
 219     public void handleSyncDeviceContacts(final InputStream input) throws IOException {
 220         final var s = new DeviceContactsInputStream(input);
 221         DeviceContact c;
 222         while (true) {
 223             try {
 224                 c = s.read();
 225             } catch (IOException e) {
 226                 if (e.getMessage() != null && e.getMessage().contains("Missing contact address!")) {
 227                     logger.warn("Sync contacts contained invalid contact, ignoring: {}", e.getMessage());
 228                     continue;
 229                 } else {
 230                     throw e;
 231                 }
 232             }
 233             if (c == null) {
 234                 break;
 235             }
 236             if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) {
 237                 account.setProfileKey(c.getProfileKey().get());
 238             }
 239             final var recipientId = account.getRecipientStore().resolveRecipientTrusted(c.getAddress());
 240             var contact = account.getContactStore().getContact(recipientId);
 241             final var builder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
 242             if (c.getName().isPresent()) {
 243                 builder.withName(c.getName().get());
 244             }
 245             if (c.getColor().isPresent()) {
 246                 builder.withColor(c.getColor().get());
 247             }
 248             if (c.getProfileKey().isPresent()) {
 249                 account.getProfileStore().storeProfileKey(recipientId, c.getProfileKey().get());
 250             }
 251             if (c.getVerified().isPresent()) {
 252                 final var verifiedMessage = c.getVerified().get();
 253                 account.getIdentityKeyStore()
 254                         .setIdentityTrustLevel(account.getRecipientStore()
 255                                         .resolveRecipientTrusted(verifiedMessage.getDestination()),
 256                                 verifiedMessage.getIdentityKey(),
 257                                 TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
 258             }
 259             if (c.getExpirationTimer().isPresent()) {
 260                 builder.withMessageExpirationTime(c.getExpirationTimer().get());
 261             }
 262             builder.withBlocked(c.isBlocked());
 263             builder.withArchived(c.isArchived());
 264             account.getContactStore().storeContact(recipientId, builder.build());
 265
 266             if (c.getAvatar().isPresent()) {
 267                 downloadContactAvatar(c.getAvatar().get(), c.getAddress());
 268             }
 269         }
 270     }
 271
 272     private void requestSyncGroups() {
 273         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
 274                 .setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS)
 275                 .build();
 276         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 277         context.getSendHelper().sendSyncMessage(message);
 278     }
 279
 280     private void requestSyncContacts() {
 281         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
 282                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS)
 283                 .build();
 284         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 285         context.getSendHelper().sendSyncMessage(message);
 286     }
 287
 288     private void requestSyncBlocked() {
 289         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
 290                 .setType(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED)
 291                 .build();
 292         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 293         context.getSendHelper().sendSyncMessage(message);
 294     }
 295
 296     private void requestSyncConfiguration() {
 297         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
 298                 .setType(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION)
 299                 .build();
 300         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 301         context.getSendHelper().sendSyncMessage(message);
 302     }
 303
 304     private void requestSyncKeys() {
 305         var r = SignalServiceProtos.SyncMessage.Request.newBuilder()
 306                 .setType(SignalServiceProtos.SyncMessage.Request.Type.KEYS)
 307                 .build();
 308         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 309         context.getSendHelper().sendSyncMessage(message);
 310     }
 311
 312     private Optional<SignalServiceAttachmentStream> createContactAvatarAttachment(SignalServiceAddress address) throws IOException {
 313         final var streamDetails = context.getAvatarStore().retrieveContactAvatar(address);
 314         if (streamDetails == null) {
 315             return Optional.absent();
 316         }
 317
 318         return Optional.of(AttachmentUtils.createAttachment(streamDetails, Optional.absent()));
 319     }
 320
 321     private void downloadContactAvatar(SignalServiceAttachment avatar, SignalServiceAddress address) {
 322         try {
 323             context.getAvatarStore()
 324                     .storeContactAvatar(address,
 325                             outputStream -> context.getAttachmentHelper().retrieveAttachment(avatar, outputStream));
 326         } catch (IOException e) {
 327             logger.warn("Failed to download avatar for contact {}, ignoring: {}", address, e.getMessage());
 328         }
 329     }
 330 }