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