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