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