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.groups.GroupId;
   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.storage.recipients.RecipientAddress;
   9 import org.asamk.signal.manager.util.AttachmentUtils;
  10 import org.asamk.signal.manager.util.IOUtils;
  11 import org.asamk.signal.manager.util.MimeUtils;
  12 import org.signal.libsignal.protocol.IdentityKey;
  13 import org.slf4j.Logger;
  14 import org.slf4j.LoggerFactory;
  15 import org.whispersystems.signalservice.api.messages.SignalServiceAttachment;
  16 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentStream;
  17 import org.whispersystems.signalservice.api.messages.multidevice.BlockedListMessage;
  18 import org.whispersystems.signalservice.api.messages.multidevice.ConfigurationMessage;
  19 import org.whispersystems.signalservice.api.messages.multidevice.ContactsMessage;
  20 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContact;
  21 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsInputStream;
  22 import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsOutputStream;
  23 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroup;
  24 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsInputStream;
  25 import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsOutputStream;
  26 import org.whispersystems.signalservice.api.messages.multidevice.KeysMessage;
  27 import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage;
  28 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
  29 import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage;
  30 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  31 import org.whispersystems.signalservice.internal.push.SignalServiceProtos;
  32
  33 import java.io.FileInputStream;
  34 import java.io.FileOutputStream;
  35 import java.io.IOException;
  36 import java.io.InputStream;
  37 import java.io.OutputStream;
  38 import java.nio.file.Files;
  39 import java.util.ArrayList;
  40 import java.util.List;
  41 import java.util.Optional;
  42 import java.util.stream.Collectors;
  43
  44 public class SyncHelper {
  45
  46     private final static Logger logger = LoggerFactory.getLogger(SyncHelper.class);
  47
  48     private final Context context;
  49     private final SignalAccount account;
  50
  51     public SyncHelper(final Context context) {
  52         this.context = context;
  53         this.account = context.getAccount();
  54     }
  55
  56     public void requestAllSyncData() {
  57         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.GROUPS);
  58         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS);
  59         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED);
  60         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION);
  61         requestSyncKeys();
  62         requestSyncPniIdentity();
  63     }
  64
  65     public void requestSyncKeys() {
  66         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.KEYS);
  67     }
  68
  69     public void requestSyncPniIdentity() {
  70         requestSyncData(SignalServiceProtos.SyncMessage.Request.Type.PNI_IDENTITY);
  71     }
  72
  73     public void sendSyncFetchProfileMessage() {
  74         context.getSendHelper()
  75                 .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 groupInfo) {
  86                         out.write(new DeviceGroup(groupInfo.getGroupId().serialize(),
  87                                 Optional.ofNullable(groupInfo.name),
  88                                 groupInfo.getMembers()
  89                                         .stream()
  90                                         .map(context.getRecipientHelper()::resolveSignalServiceAddress)
  91                                         .toList(),
  92                                 context.getGroupHelper().createGroupAvatarAttachment(groupInfo.getGroupId()),
  93                                 groupInfo.isMember(account.getSelfRecipientId()),
  94                                 Optional.of(groupInfo.messageExpirationTime),
  95                                 Optional.ofNullable(groupInfo.color),
  96                                 groupInfo.blocked,
  97                                 Optional.empty(),
  98                                 groupInfo.archived));
  99                     }
 100                 }
 101             }
 102
 103             if (groupsFile.exists() && groupsFile.length() > 0) {
 104                 try (var groupsFileStream = new FileInputStream(groupsFile)) {
 105                     var attachmentStream = SignalServiceAttachment.newStreamBuilder()
 106                             .withStream(groupsFileStream)
 107                             .withContentType(MimeUtils.OCTET_STREAM)
 108                             .withLength(groupsFile.length())
 109                             .build();
 110
 111                     context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
 112                 }
 113             }
 114         } finally {
 115             try {
 116                 Files.delete(groupsFile.toPath());
 117             } catch (IOException e) {
 118                 logger.warn("Failed to delete groups temp file “{}”, ignoring: {}", groupsFile, e.getMessage());
 119             }
 120         }
 121     }
 122
 123     public void sendContacts() throws IOException {
 124         var contactsFile = IOUtils.createTempFile();
 125
 126         try {
 127             try (OutputStream fos = new FileOutputStream(contactsFile)) {
 128                 var out = new DeviceContactsOutputStream(fos);
 129                 for (var contactPair : account.getContactStore().getContacts()) {
 130                     final var recipientId = contactPair.first();
 131                     final var contact = contactPair.second();
 132                     final var address = context.getRecipientHelper().resolveSignalServiceAddress(recipientId);
 133
 134                     var currentIdentity = account.getIdentityKeyStore().getIdentityInfo(address.getServiceId());
 135                     VerifiedMessage verifiedMessage = null;
 136                     if (currentIdentity != null) {
 137                         verifiedMessage = new VerifiedMessage(address,
 138                                 currentIdentity.getIdentityKey(),
 139                                 currentIdentity.getTrustLevel().toVerifiedState(),
 140                                 currentIdentity.getDateAddedTimestamp());
 141                     }
 142
 143                     var profileKey = account.getProfileStore().getProfileKey(recipientId);
 144                     out.write(new DeviceContact(address,
 145                             Optional.ofNullable(contact.getName()),
 146                             createContactAvatarAttachment(new RecipientAddress(address)),
 147                             Optional.ofNullable(contact.getColor()),
 148                             Optional.ofNullable(verifiedMessage),
 149                             Optional.ofNullable(profileKey),
 150                             contact.isBlocked(),
 151                             Optional.of(contact.getMessageExpirationTime()),
 152                             Optional.empty(),
 153                             contact.isArchived()));
 154                 }
 155
 156                 if (account.getProfileKey() != null) {
 157                     // Send our own profile key as well
 158                     out.write(new DeviceContact(account.getSelfAddress(),
 159                             Optional.empty(),
 160                             Optional.empty(),
 161                             Optional.empty(),
 162                             Optional.empty(),
 163                             Optional.of(account.getProfileKey()),
 164                             false,
 165                             Optional.empty(),
 166                             Optional.empty(),
 167                             false));
 168                 }
 169             }
 170
 171             if (contactsFile.exists() && contactsFile.length() > 0) {
 172                 try (var contactsFileStream = new FileInputStream(contactsFile)) {
 173                     var attachmentStream = SignalServiceAttachment.newStreamBuilder()
 174                             .withStream(contactsFileStream)
 175                             .withContentType(MimeUtils.OCTET_STREAM)
 176                             .withLength(contactsFile.length())
 177                             .build();
 178
 179                     context.getSendHelper()
 180                             .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() {
 194         var addresses = new ArrayList<SignalServiceAddress>();
 195         for (var record : account.getContactStore().getContacts()) {
 196             if (record.second().isBlocked()) {
 197                 addresses.add(context.getRecipientHelper().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         context.getSendHelper()
 207                 .sendSyncMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds)));
 208     }
 209
 210     public void sendVerifiedMessage(
 211             SignalServiceAddress destination, IdentityKey identityKey, TrustLevel trustLevel
 212     ) throws IOException {
 213         var verifiedMessage = new VerifiedMessage(destination,
 214                 identityKey,
 215                 trustLevel.toVerifiedState(),
 216                 System.currentTimeMillis());
 217         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage));
 218     }
 219
 220     public void sendKeysMessage() {
 221         var keysMessage = new KeysMessage(Optional.ofNullable(account.getStorageKey()));
 222         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forKeys(keysMessage));
 223     }
 224
 225     public void sendConfigurationMessage() {
 226         final var config = account.getConfigurationStore();
 227         var configurationMessage = new ConfigurationMessage(Optional.ofNullable(config.getReadReceipts()),
 228                 Optional.ofNullable(config.getUnidentifiedDeliveryIndicators()),
 229                 Optional.ofNullable(config.getTypingIndicators()),
 230                 Optional.ofNullable(config.getLinkPreviews()));
 231         context.getSendHelper().sendSyncMessage(SignalServiceSyncMessage.forConfiguration(configurationMessage));
 232     }
 233
 234     public void handleSyncDeviceGroups(final InputStream input) {
 235         final var s = new DeviceGroupsInputStream(input);
 236         DeviceGroup g;
 237         while (true) {
 238             try {
 239                 g = s.read();
 240             } catch (IOException e) {
 241                 logger.warn("Sync groups contained invalid group, ignoring: {}", e.getMessage());
 242                 continue;
 243             }
 244             if (g == null) {
 245                 break;
 246             }
 247             var syncGroup = account.getGroupStore().getOrCreateGroupV1(GroupId.v1(g.getId()));
 248             if (syncGroup != null) {
 249                 if (g.getName().isPresent()) {
 250                     syncGroup.name = g.getName().get();
 251                 }
 252                 syncGroup.addMembers(g.getMembers()
 253                         .stream()
 254                         .map(account.getRecipientResolver()::resolveRecipient)
 255                         .collect(Collectors.toSet()));
 256                 if (!g.isActive()) {
 257                     syncGroup.removeMember(account.getSelfRecipientId());
 258                 } else {
 259                     // Add ourself to the member set as it's marked as active
 260                     syncGroup.addMembers(List.of(account.getSelfRecipientId()));
 261                 }
 262                 syncGroup.blocked = g.isBlocked();
 263                 if (g.getColor().isPresent()) {
 264                     syncGroup.color = g.getColor().get();
 265                 }
 266
 267                 if (g.getAvatar().isPresent()) {
 268                     context.getGroupHelper().downloadGroupAvatar(syncGroup.getGroupId(), g.getAvatar().get());
 269                 }
 270                 syncGroup.archived = g.isArchived();
 271                 account.getGroupStore().updateGroup(syncGroup);
 272             }
 273         }
 274     }
 275
 276     public void handleSyncDeviceContacts(final InputStream input) throws IOException {
 277         final var s = new DeviceContactsInputStream(input);
 278         DeviceContact c;
 279         while (true) {
 280             try {
 281                 c = s.read();
 282             } catch (IOException e) {
 283                 if (e.getMessage() != null && e.getMessage().contains("Missing contact address!")) {
 284                     logger.warn("Sync contacts contained invalid contact, ignoring: {}", e.getMessage());
 285                     continue;
 286                 } else {
 287                     throw e;
 288                 }
 289             }
 290             if (c == null) {
 291                 break;
 292             }
 293             if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) {
 294                 account.setProfileKey(c.getProfileKey().get());
 295             }
 296             final var recipientId = account.getRecipientTrustedResolver().resolveRecipientTrusted(c.getAddress());
 297             var contact = account.getContactStore().getContact(recipientId);
 298             final var builder = contact == null ? Contact.newBuilder() : Contact.newBuilder(contact);
 299             if (c.getName().isPresent()) {
 300                 builder.withGivenName(c.getName().get());
 301                 builder.withFamilyName(null);
 302             }
 303             if (c.getColor().isPresent()) {
 304                 builder.withColor(c.getColor().get());
 305             }
 306             if (c.getProfileKey().isPresent()) {
 307                 account.getProfileStore().storeProfileKey(recipientId, c.getProfileKey().get());
 308             }
 309             if (c.getVerified().isPresent()) {
 310                 final var verifiedMessage = c.getVerified().get();
 311                 account.getIdentityKeyStore()
 312                         .setIdentityTrustLevel(verifiedMessage.getDestination().getServiceId(),
 313                                 verifiedMessage.getIdentityKey(),
 314                                 TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
 315             }
 316             if (c.getExpirationTimer().isPresent()) {
 317                 builder.withMessageExpirationTime(c.getExpirationTimer().get());
 318             }
 319             builder.withBlocked(c.isBlocked());
 320             builder.withArchived(c.isArchived());
 321             account.getContactStore().storeContact(recipientId, builder.build());
 322
 323             if (c.getAvatar().isPresent()) {
 324                 downloadContactAvatar(c.getAvatar().get(), new RecipientAddress(c.getAddress()));
 325             }
 326         }
 327     }
 328
 329     private void requestSyncData(final SignalServiceProtos.SyncMessage.Request.Type type) {
 330         var r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(type).build();
 331         var message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 332         context.getSendHelper().sendSyncMessage(message);
 333     }
 334
 335     private Optional<SignalServiceAttachmentStream> createContactAvatarAttachment(RecipientAddress address) throws IOException {
 336         final var streamDetails = context.getAvatarStore().retrieveContactAvatar(address);
 337         if (streamDetails == null) {
 338             return Optional.empty();
 339         }
 340
 341         return Optional.of(AttachmentUtils.createAttachmentStream(streamDetails, Optional.empty()));
 342     }
 343
 344     private void downloadContactAvatar(SignalServiceAttachment avatar, RecipientAddress address) {
 345         try {
 346             context.getAvatarStore()
 347                     .storeContactAvatar(address,
 348                             outputStream -> context.getAttachmentHelper().retrieveAttachment(avatar, outputStream));
 349         } catch (IOException e) {
 350             logger.warn("Failed to download avatar for contact {}, ignoring: {}", address, e.getMessage());
 351         }
 352     }
 353 }