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

   1 package org.asamk.signal.manager.helper;
   2
   3 import org.asamk.signal.manager.Manager;
   4 import org.asamk.signal.manager.SignalDependencies;
   5 import org.asamk.signal.manager.actions.HandleAction;
   6 import org.asamk.signal.manager.actions.RefreshPreKeysAction;
   7 import org.asamk.signal.manager.actions.RenewSessionAction;
   8 import org.asamk.signal.manager.actions.ResendMessageAction;
   9 import org.asamk.signal.manager.actions.RetrieveProfileAction;
  10 import org.asamk.signal.manager.actions.RetrieveStorageDataAction;
  11 import org.asamk.signal.manager.actions.SendGroupInfoAction;
  12 import org.asamk.signal.manager.actions.SendGroupInfoRequestAction;
  13 import org.asamk.signal.manager.actions.SendPniIdentityKeyAction;
  14 import org.asamk.signal.manager.actions.SendReceiptAction;
  15 import org.asamk.signal.manager.actions.SendRetryMessageRequestAction;
  16 import org.asamk.signal.manager.actions.SendSyncBlockedListAction;
  17 import org.asamk.signal.manager.actions.SendSyncConfigurationAction;
  18 import org.asamk.signal.manager.actions.SendSyncContactsAction;
  19 import org.asamk.signal.manager.actions.SendSyncGroupsAction;
  20 import org.asamk.signal.manager.actions.SendSyncKeysAction;
  21 import org.asamk.signal.manager.api.MessageEnvelope;
  22 import org.asamk.signal.manager.api.Pair;
  23 import org.asamk.signal.manager.api.StickerPackId;
  24 import org.asamk.signal.manager.api.TrustLevel;
  25 import org.asamk.signal.manager.api.UntrustedIdentityException;
  26 import org.asamk.signal.manager.groups.GroupId;
  27 import org.asamk.signal.manager.groups.GroupNotFoundException;
  28 import org.asamk.signal.manager.groups.GroupUtils;
  29 import org.asamk.signal.manager.jobs.RetrieveStickerPackJob;
  30 import org.asamk.signal.manager.storage.SignalAccount;
  31 import org.asamk.signal.manager.storage.groups.GroupInfoV1;
  32 import org.asamk.signal.manager.storage.recipients.Profile;
  33 import org.asamk.signal.manager.storage.recipients.RecipientId;
  34 import org.asamk.signal.manager.storage.stickers.Sticker;
  35 import org.asamk.signal.manager.util.KeyUtils;
  36 import org.signal.libsignal.metadata.ProtocolInvalidKeyException;
  37 import org.signal.libsignal.metadata.ProtocolInvalidKeyIdException;
  38 import org.signal.libsignal.metadata.ProtocolInvalidMessageException;
  39 import org.signal.libsignal.metadata.ProtocolNoSessionException;
  40 import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
  41 import org.signal.libsignal.metadata.SelfSendException;
  42 import org.signal.libsignal.protocol.SignalProtocolAddress;
  43 import org.signal.libsignal.protocol.message.DecryptionErrorMessage;
  44 import org.signal.libsignal.zkgroup.InvalidInputException;
  45 import org.signal.libsignal.zkgroup.profiles.ProfileKey;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48 import org.whispersystems.signalservice.api.messages.SignalServiceContent;
  49 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
  50 import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
  51 import org.whispersystems.signalservice.api.messages.SignalServiceGroup;
  52 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
  53 import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage;
  54 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  55
  56 import java.util.ArrayList;
  57 import java.util.List;
  58 import java.util.stream.Collectors;
  59
  60 public final class IncomingMessageHandler {
  61
  62     private final static Logger logger = LoggerFactory.getLogger(IncomingMessageHandler.class);
  63
  64     private final SignalAccount account;
  65     private final SignalDependencies dependencies;
  66     private final Context context;
  67
  68     public IncomingMessageHandler(final Context context) {
  69         this.account = context.getAccount();
  70         this.dependencies = context.getDependencies();
  71         this.context = context;
  72     }
  73
  74     public Pair<List<HandleAction>, Exception> handleRetryEnvelope(
  75             final SignalServiceEnvelope envelope,
  76             final boolean ignoreAttachments,
  77             final Manager.ReceiveMessageHandler handler
  78     ) {
  79         final List<HandleAction> actions = new ArrayList<>();
  80         if (envelope.isPreKeySignalMessage()) {
  81             actions.add(RefreshPreKeysAction.create());
  82         }
  83
  84         SignalServiceContent content = null;
  85         if (!envelope.isReceipt()) {
  86             account.getIdentityKeyStore().setRetryingDecryption(true);
  87             try {
  88                 content = dependencies.getCipher().decrypt(envelope);
  89             } catch (ProtocolUntrustedIdentityException e) {
  90                 final var recipientId = account.getRecipientStore().resolveRecipient(e.getSender());
  91                 final var exception = new UntrustedIdentityException(account.getRecipientStore()
  92                         .resolveRecipientAddress(recipientId), e.getSenderDevice());
  93                 return new Pair<>(List.of(), exception);
  94             } catch (Exception e) {
  95                 return new Pair<>(List.of(), e);
  96             } finally {
  97                 account.getIdentityKeyStore().setRetryingDecryption(false);
  98             }
  99         }
 100         actions.addAll(checkAndHandleMessage(envelope, content, ignoreAttachments, handler, null));
 101         return new Pair<>(actions, null);
 102     }
 103
 104     public Pair<List<HandleAction>, Exception> handleEnvelope(
 105             final SignalServiceEnvelope envelope,
 106             final boolean ignoreAttachments,
 107             final Manager.ReceiveMessageHandler handler
 108     ) {
 109         final var actions = new ArrayList<HandleAction>();
 110         if (envelope.hasSourceUuid()) {
 111             // Store uuid if we don't have it already
 112             // address/uuid in envelope is sent by server
 113             account.getRecipientStore().resolveRecipientTrusted(envelope.getSourceAddress());
 114         }
 115         SignalServiceContent content = null;
 116         Exception exception = null;
 117         if (!envelope.isReceipt()) {
 118             try {
 119                 content = dependencies.getCipher().decrypt(envelope);
 120             } catch (ProtocolUntrustedIdentityException e) {
 121                 final var recipientId = account.getRecipientStore().resolveRecipient(e.getSender());
 122                 actions.add(new RetrieveProfileAction(recipientId));
 123                 exception = new UntrustedIdentityException(account.getRecipientStore()
 124                         .resolveRecipientAddress(recipientId), e.getSenderDevice());
 125             } catch (ProtocolInvalidKeyIdException | ProtocolInvalidKeyException | ProtocolNoSessionException |
 126                      ProtocolInvalidMessageException e) {
 127                 logger.debug("Failed to decrypt incoming message", e);
 128                 final var sender = account.getRecipientStore().resolveRecipient(e.getSender());
 129                 if (context.getContactHelper().isContactBlocked(sender)) {
 130                     logger.debug("Received invalid message from blocked contact, ignoring.");
 131                 } else {
 132                     final var senderProfile = context.getProfileHelper().getRecipientProfile(sender);
 133                     final var selfProfile = context.getProfileHelper().getSelfProfile();
 134                     if ((!sender.equals(account.getSelfRecipientId()) || e.getSenderDevice() != account.getDeviceId())
 135                             && senderProfile != null
 136                             && senderProfile.getCapabilities().contains(Profile.Capability.senderKey)
 137                             && selfProfile != null
 138                             && selfProfile.getCapabilities().contains(Profile.Capability.senderKey)) {
 139                         logger.debug("Received invalid message, requesting message resend.");
 140                         actions.add(new SendRetryMessageRequestAction(sender, e, envelope));
 141                     } else {
 142                         logger.debug("Received invalid message, queuing renew session action.");
 143                         actions.add(new RenewSessionAction(sender));
 144                     }
 145                 }
 146                 exception = e;
 147             } catch (SelfSendException e) {
 148                 logger.debug("Dropping unidentified message from self.");
 149                 return new Pair<>(List.of(), null);
 150             } catch (Exception e) {
 151                 logger.debug("Failed to handle incoming message", e);
 152                 exception = e;
 153             }
 154         }
 155
 156         actions.addAll(checkAndHandleMessage(envelope, content, ignoreAttachments, handler, exception));
 157         return new Pair<>(actions, exception);
 158     }
 159
 160     private List<HandleAction> checkAndHandleMessage(
 161             final SignalServiceEnvelope envelope,
 162             final SignalServiceContent content,
 163             final boolean ignoreAttachments,
 164             final Manager.ReceiveMessageHandler handler,
 165             final Exception exception
 166     ) {
 167         if (!envelope.hasSourceUuid() && content != null) {
 168             // Store uuid if we don't have it already
 169             // address/uuid is validated by unidentified sender certificate
 170             account.getRecipientStore().resolveRecipientTrusted(content.getSender());
 171         }
 172         if (envelope.isReceipt()) {
 173             final var senderPair = getSender(envelope, content);
 174             final var sender = senderPair.first();
 175             final var senderDeviceId = senderPair.second();
 176             account.getMessageSendLogStore().deleteEntryForRecipient(envelope.getTimestamp(), sender, senderDeviceId);
 177         }
 178
 179         if (isMessageBlocked(envelope, content)) {
 180             logger.info("Ignoring a message from blocked user/group: {}", envelope.getTimestamp());
 181             return List.of();
 182         } else if (isNotAllowedToSendToGroup(envelope, content)) {
 183             logger.info("Ignoring a group message from an unauthorized sender (no member or admin): {} {}",
 184                     (envelope.hasSourceUuid() ? envelope.getSourceAddress() : content.getSender()).getIdentifier(),
 185                     envelope.getTimestamp());
 186             return List.of();
 187         } else {
 188             List<HandleAction> actions;
 189             if (content != null) {
 190                 actions = handleMessage(envelope, content, ignoreAttachments);
 191             } else {
 192                 actions = List.of();
 193             }
 194             handler.handleMessage(MessageEnvelope.from(envelope,
 195                     content,
 196                     account.getRecipientStore(),
 197                     account.getRecipientStore()::resolveRecipientAddress,
 198                     context.getAttachmentHelper()::getAttachmentFile,
 199                     exception), exception);
 200             return actions;
 201         }
 202     }
 203
 204     public List<HandleAction> handleMessage(
 205             SignalServiceEnvelope envelope, SignalServiceContent content, boolean ignoreAttachments
 206     ) {
 207         var actions = new ArrayList<HandleAction>();
 208         final var senderPair = getSender(envelope, content);
 209         final var sender = senderPair.first();
 210         final var senderDeviceId = senderPair.second();
 211
 212         if (content.getReceiptMessage().isPresent()) {
 213             final var message = content.getReceiptMessage().get();
 214             if (message.isDeliveryReceipt()) {
 215                 account.getMessageSendLogStore()
 216                         .deleteEntriesForRecipient(message.getTimestamps(), sender, senderDeviceId);
 217             }
 218         }
 219
 220         if (content.getSenderKeyDistributionMessage().isPresent()) {
 221             final var message = content.getSenderKeyDistributionMessage().get();
 222             final var protocolAddress = new SignalProtocolAddress(context.getRecipientHelper()
 223                     .resolveSignalServiceAddress(sender)
 224                     .getIdentifier(), senderDeviceId);
 225             logger.debug("Received a sender key distribution message for distributionId {} from {}",
 226                     message.getDistributionId(),
 227                     protocolAddress);
 228             dependencies.getMessageSender().processSenderKeyDistributionMessage(protocolAddress, message);
 229         }
 230
 231         if (content.getDecryptionErrorMessage().isPresent()) {
 232             var message = content.getDecryptionErrorMessage().get();
 233             logger.debug("Received a decryption error message from {}.{} (resend request for {})",
 234                     sender,
 235                     senderDeviceId,
 236                     message.getTimestamp());
 237             if (message.getDeviceId() == account.getDeviceId()) {
 238                 handleDecryptionErrorMessage(actions, sender, senderDeviceId, message);
 239             } else {
 240                 logger.debug("Request is for another one of our devices");
 241             }
 242         }
 243
 244         if (content.getDataMessage().isPresent()) {
 245             var message = content.getDataMessage().get();
 246
 247             if (content.isNeedsReceipt()) {
 248                 actions.add(new SendReceiptAction(sender, message.getTimestamp()));
 249             }
 250
 251             actions.addAll(handleSignalServiceDataMessage(message,
 252                     false,
 253                     sender,
 254                     account.getSelfRecipientId(),
 255                     ignoreAttachments));
 256         }
 257
 258         if (content.getSyncMessage().isPresent()) {
 259             var syncMessage = content.getSyncMessage().get();
 260             actions.addAll(handleSyncMessage(syncMessage, sender, ignoreAttachments));
 261         }
 262
 263         return actions;
 264     }
 265
 266     private void handleDecryptionErrorMessage(
 267             final List<HandleAction> actions,
 268             final RecipientId sender,
 269             final int senderDeviceId,
 270             final DecryptionErrorMessage message
 271     ) {
 272         final var logEntries = account.getMessageSendLogStore()
 273                 .findMessages(sender, senderDeviceId, message.getTimestamp(), message.getRatchetKey().isEmpty());
 274
 275         for (final var logEntry : logEntries) {
 276             actions.add(new ResendMessageAction(sender, message.getTimestamp(), logEntry));
 277         }
 278
 279         if (message.getRatchetKey().isPresent()) {
 280             if (account.getSessionStore().isCurrentRatchetKey(sender, senderDeviceId, message.getRatchetKey().get())) {
 281                 if (logEntries.isEmpty()) {
 282                     logger.debug("Renewing the session with sender");
 283                     actions.add(new RenewSessionAction(sender));
 284                 } else {
 285                     logger.trace("Archiving the session with sender, a resend message has already been queued");
 286                     context.getAccount().getSessionStore().archiveSessions(sender);
 287                 }
 288             }
 289             return;
 290         }
 291
 292         var found = false;
 293         for (final var logEntry : logEntries) {
 294             if (logEntry.groupId().isEmpty()) {
 295                 continue;
 296             }
 297             final var group = account.getGroupStore().getGroup(logEntry.groupId().get());
 298             if (group == null) {
 299                 continue;
 300             }
 301             found = true;
 302             logger.trace("Deleting shared sender key with {} ({}): {}",
 303                     sender,
 304                     senderDeviceId,
 305                     group.getDistributionId());
 306             account.getSenderKeyStore().deleteSharedWith(sender, senderDeviceId, group.getDistributionId());
 307         }
 308         if (!found) {
 309             logger.debug("Reset all shared sender keys with this recipient, no related message found in send log");
 310             account.getSenderKeyStore().deleteSharedWith(sender);
 311         }
 312     }
 313
 314     private List<HandleAction> handleSyncMessage(
 315             final SignalServiceSyncMessage syncMessage, final RecipientId sender, final boolean ignoreAttachments
 316     ) {
 317         var actions = new ArrayList<HandleAction>();
 318         account.setMultiDevice(true);
 319         if (syncMessage.getSent().isPresent()) {
 320             var message = syncMessage.getSent().get();
 321             final var destination = message.getDestination().orElse(null);
 322             if (message.getDataMessage().isPresent()) {
 323                 actions.addAll(handleSignalServiceDataMessage(message.getDataMessage().get(),
 324                         true,
 325                         sender,
 326                         destination == null ? null : context.getRecipientHelper().resolveRecipient(destination),
 327                         ignoreAttachments));
 328             }
 329         }
 330         if (syncMessage.getRequest().isPresent() && account.isMasterDevice()) {
 331             var rm = syncMessage.getRequest().get();
 332             if (rm.isContactsRequest()) {
 333                 actions.add(SendSyncContactsAction.create());
 334             }
 335             if (rm.isGroupsRequest()) {
 336                 actions.add(SendSyncGroupsAction.create());
 337             }
 338             if (rm.isBlockedListRequest()) {
 339                 actions.add(SendSyncBlockedListAction.create());
 340             }
 341             if (rm.isKeysRequest()) {
 342                 actions.add(SendSyncKeysAction.create());
 343             }
 344             if (rm.isConfigurationRequest()) {
 345                 actions.add(SendSyncConfigurationAction.create());
 346             }
 347             if (rm.isPniIdentityRequest()) {
 348                 actions.add(SendPniIdentityKeyAction.create());
 349             }
 350         }
 351         if (syncMessage.getGroups().isPresent()) {
 352             logger.warn("Received a group v1 sync message, that can't be handled anymore, ignoring.");
 353         }
 354         if (syncMessage.getBlockedList().isPresent()) {
 355             final var blockedListMessage = syncMessage.getBlockedList().get();
 356             for (var address : blockedListMessage.getAddresses()) {
 357                 context.getContactHelper()
 358                         .setContactBlocked(context.getRecipientHelper().resolveRecipient(address), true);
 359             }
 360             for (var groupId : blockedListMessage.getGroupIds()
 361                     .stream()
 362                     .map(GroupId::unknownVersion)
 363                     .collect(Collectors.toSet())) {
 364                 try {
 365                     context.getGroupHelper().setGroupBlocked(groupId, true);
 366                 } catch (GroupNotFoundException e) {
 367                     logger.warn("BlockedListMessage contained groupID that was not found in GroupStore: {}",
 368                             groupId.toBase64());
 369                 }
 370             }
 371         }
 372         if (syncMessage.getContacts().isPresent()) {
 373             try {
 374                 final var contactsMessage = syncMessage.getContacts().get();
 375                 context.getAttachmentHelper()
 376                         .retrieveAttachment(contactsMessage.getContactsStream(),
 377                                 context.getSyncHelper()::handleSyncDeviceContacts);
 378             } catch (Exception e) {
 379                 logger.warn("Failed to handle received sync contacts, ignoring: {}", e.getMessage());
 380             }
 381         }
 382         if (syncMessage.getVerified().isPresent()) {
 383             final var verifiedMessage = syncMessage.getVerified().get();
 384             account.getIdentityKeyStore()
 385                     .setIdentityTrustLevel(account.getRecipientStore()
 386                                     .resolveRecipientTrusted(verifiedMessage.getDestination()),
 387                             verifiedMessage.getIdentityKey(),
 388                             TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
 389         }
 390         if (syncMessage.getStickerPackOperations().isPresent()) {
 391             final var stickerPackOperationMessages = syncMessage.getStickerPackOperations().get();
 392             for (var m : stickerPackOperationMessages) {
 393                 if (m.getPackId().isEmpty()) {
 394                     continue;
 395                 }
 396                 final var stickerPackId = StickerPackId.deserialize(m.getPackId().get());
 397                 final var installed = m.getType().isEmpty()
 398                         || m.getType().get() == StickerPackOperationMessage.Type.INSTALL;
 399
 400                 var sticker = account.getStickerStore().getStickerPack(stickerPackId);
 401                 if (m.getPackKey().isPresent()) {
 402                     if (sticker == null) {
 403                         sticker = new Sticker(stickerPackId, m.getPackKey().get());
 404                     }
 405                     if (installed) {
 406                         context.getJobExecutor()
 407                                 .enqueueJob(new RetrieveStickerPackJob(stickerPackId, m.getPackKey().get()));
 408                     }
 409                 }
 410
 411                 if (sticker != null) {
 412                     sticker.setInstalled(installed);
 413                     account.getStickerStore().updateSticker(sticker);
 414                 }
 415             }
 416         }
 417         if (syncMessage.getFetchType().isPresent()) {
 418             switch (syncMessage.getFetchType().get()) {
 419                 case LOCAL_PROFILE:
 420                     actions.add(new RetrieveProfileAction(account.getSelfRecipientId()));
 421                 case STORAGE_MANIFEST:
 422                     actions.add(RetrieveStorageDataAction.create());
 423             }
 424         }
 425         if (syncMessage.getKeys().isPresent()) {
 426             final var keysMessage = syncMessage.getKeys().get();
 427             if (keysMessage.getStorageService().isPresent()) {
 428                 final var storageKey = keysMessage.getStorageService().get();
 429                 account.setStorageKey(storageKey);
 430                 actions.add(RetrieveStorageDataAction.create());
 431             }
 432         }
 433         if (syncMessage.getConfiguration().isPresent()) {
 434             final var configurationMessage = syncMessage.getConfiguration().get();
 435             final var configurationStore = account.getConfigurationStore();
 436             if (configurationMessage.getReadReceipts().isPresent()) {
 437                 configurationStore.setReadReceipts(configurationMessage.getReadReceipts().get());
 438             }
 439             if (configurationMessage.getLinkPreviews().isPresent()) {
 440                 configurationStore.setLinkPreviews(configurationMessage.getLinkPreviews().get());
 441             }
 442             if (configurationMessage.getTypingIndicators().isPresent()) {
 443                 configurationStore.setTypingIndicators(configurationMessage.getTypingIndicators().get());
 444             }
 445             if (configurationMessage.getUnidentifiedDeliveryIndicators().isPresent()) {
 446                 configurationStore.setUnidentifiedDeliveryIndicators(configurationMessage.getUnidentifiedDeliveryIndicators()
 447                         .get());
 448             }
 449         }
 450         if (syncMessage.getPniIdentity().isPresent()) {
 451             final var pniIdentity = syncMessage.getPniIdentity().get();
 452             account.setPniIdentityKeyPair(KeyUtils.getIdentityKeyPair(pniIdentity.getPublicKey().toByteArray(),
 453                     pniIdentity.getPrivateKey().toByteArray()));
 454         }
 455         return actions;
 456     }
 457
 458     private boolean isMessageBlocked(SignalServiceEnvelope envelope, SignalServiceContent content) {
 459         SignalServiceAddress source;
 460         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 461             source = envelope.getSourceAddress();
 462         } else if (content != null) {
 463             source = content.getSender();
 464         } else {
 465             return false;
 466         }
 467         final var recipientId = context.getRecipientHelper().resolveRecipient(source);
 468         if (context.getContactHelper().isContactBlocked(recipientId)) {
 469             return true;
 470         }
 471
 472         if (content != null && content.getDataMessage().isPresent()) {
 473             var message = content.getDataMessage().get();
 474             if (message.getGroupContext().isPresent()) {
 475                 var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
 476                 return context.getGroupHelper().isGroupBlocked(groupId);
 477             }
 478         }
 479
 480         return false;
 481     }
 482
 483     private boolean isNotAllowedToSendToGroup(SignalServiceEnvelope envelope, SignalServiceContent content) {
 484         SignalServiceAddress source;
 485         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 486             source = envelope.getSourceAddress();
 487         } else if (content != null) {
 488             source = content.getSender();
 489         } else {
 490             return false;
 491         }
 492
 493         if (content == null || content.getDataMessage().isEmpty()) {
 494             return false;
 495         }
 496
 497         var message = content.getDataMessage().get();
 498         if (message.getGroupContext().isEmpty()) {
 499             return false;
 500         }
 501
 502         if (message.getGroupContext().get().getGroupV1().isPresent()) {
 503             var groupInfo = message.getGroupContext().get().getGroupV1().get();
 504             if (groupInfo.getType() == SignalServiceGroup.Type.QUIT) {
 505                 return false;
 506             }
 507         }
 508
 509         var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
 510         var group = context.getGroupHelper().getGroup(groupId);
 511         if (group == null) {
 512             return false;
 513         }
 514
 515         final var recipientId = context.getRecipientHelper().resolveRecipient(source);
 516         if (!group.isMember(recipientId) && !(group.isPendingMember(recipientId) && message.isGroupV2Update())) {
 517             return true;
 518         }
 519
 520         if (group.isAnnouncementGroup() && !group.isAdmin(recipientId)) {
 521             return message.getBody().isPresent()
 522                     || message.getAttachments().isPresent()
 523                     || message.getQuote()
 524                     .isPresent()
 525                     || message.getPreviews().isPresent()
 526                     || message.getMentions().isPresent()
 527                     || message.getSticker().isPresent();
 528         }
 529         return false;
 530     }
 531
 532     private List<HandleAction> handleSignalServiceDataMessage(
 533             SignalServiceDataMessage message,
 534             boolean isSync,
 535             RecipientId source,
 536             RecipientId destination,
 537             boolean ignoreAttachments
 538     ) {
 539         var actions = new ArrayList<HandleAction>();
 540         if (message.getGroupContext().isPresent()) {
 541             if (message.getGroupContext().get().getGroupV1().isPresent()) {
 542                 var groupInfo = message.getGroupContext().get().getGroupV1().get();
 543                 var groupId = GroupId.v1(groupInfo.getGroupId());
 544                 var group = context.getGroupHelper().getGroup(groupId);
 545                 if (group == null || group instanceof GroupInfoV1) {
 546                     var groupV1 = (GroupInfoV1) group;
 547                     switch (groupInfo.getType()) {
 548                         case UPDATE: {
 549                             if (groupV1 == null) {
 550                                 groupV1 = new GroupInfoV1(groupId);
 551                             }
 552
 553                             if (groupInfo.getAvatar().isPresent()) {
 554                                 var avatar = groupInfo.getAvatar().get();
 555                                 context.getGroupHelper().downloadGroupAvatar(groupV1.getGroupId(), avatar);
 556                             }
 557
 558                             if (groupInfo.getName().isPresent()) {
 559                                 groupV1.name = groupInfo.getName().get();
 560                             }
 561
 562                             if (groupInfo.getMembers().isPresent()) {
 563                                 groupV1.addMembers(groupInfo.getMembers()
 564                                         .get()
 565                                         .stream()
 566                                         .map(context.getRecipientHelper()::resolveRecipient)
 567                                         .collect(Collectors.toSet()));
 568                             }
 569
 570                             account.getGroupStore().updateGroup(groupV1);
 571                             break;
 572                         }
 573                         case DELIVER:
 574                             if (groupV1 == null && !isSync) {
 575                                 actions.add(new SendGroupInfoRequestAction(source, groupId));
 576                             }
 577                             break;
 578                         case QUIT: {
 579                             if (groupV1 != null) {
 580                                 groupV1.removeMember(source);
 581                                 account.getGroupStore().updateGroup(groupV1);
 582                             }
 583                             break;
 584                         }
 585                         case REQUEST_INFO:
 586                             if (groupV1 != null && !isSync) {
 587                                 actions.add(new SendGroupInfoAction(source, groupV1.getGroupId()));
 588                             }
 589                             break;
 590                     }
 591                 } else {
 592                     // Received a group v1 message for a v2 group
 593                 }
 594             }
 595             if (message.getGroupContext().get().getGroupV2().isPresent()) {
 596                 final var groupContext = message.getGroupContext().get().getGroupV2().get();
 597                 final var groupMasterKey = groupContext.getMasterKey();
 598
 599                 context.getGroupHelper()
 600                         .getOrMigrateGroup(groupMasterKey,
 601                                 groupContext.getRevision(),
 602                                 groupContext.hasSignedGroupChange() ? groupContext.getSignedGroupChange() : null);
 603             }
 604         }
 605
 606         final var conversationPartnerAddress = isSync ? destination : source;
 607         if (conversationPartnerAddress != null && message.isEndSession()) {
 608             account.getSessionStore().deleteAllSessions(conversationPartnerAddress);
 609         }
 610         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
 611             if (message.getGroupContext().isPresent()) {
 612                 if (message.getGroupContext().get().getGroupV1().isPresent()) {
 613                     var groupInfo = message.getGroupContext().get().getGroupV1().get();
 614                     var group = account.getGroupStore().getOrCreateGroupV1(GroupId.v1(groupInfo.getGroupId()));
 615                     if (group != null) {
 616                         if (group.messageExpirationTime != message.getExpiresInSeconds()) {
 617                             group.messageExpirationTime = message.getExpiresInSeconds();
 618                             account.getGroupStore().updateGroup(group);
 619                         }
 620                     }
 621                 } else if (message.getGroupContext().get().getGroupV2().isPresent()) {
 622                     // disappearing message timer already stored in the DecryptedGroup
 623                 }
 624             } else if (conversationPartnerAddress != null) {
 625                 context.getContactHelper()
 626                         .setExpirationTimer(conversationPartnerAddress, message.getExpiresInSeconds());
 627             }
 628         }
 629         if (!ignoreAttachments) {
 630             if (message.getAttachments().isPresent()) {
 631                 for (var attachment : message.getAttachments().get()) {
 632                     context.getAttachmentHelper().downloadAttachment(attachment);
 633                 }
 634             }
 635             if (message.getSharedContacts().isPresent()) {
 636                 for (var contact : message.getSharedContacts().get()) {
 637                     if (contact.getAvatar().isPresent()) {
 638                         context.getAttachmentHelper().downloadAttachment(contact.getAvatar().get().getAttachment());
 639                     }
 640                 }
 641             }
 642             if (message.getPreviews().isPresent()) {
 643                 final var previews = message.getPreviews().get();
 644                 for (var preview : previews) {
 645                     if (preview.getImage().isPresent()) {
 646                         context.getAttachmentHelper().downloadAttachment(preview.getImage().get());
 647                     }
 648                 }
 649             }
 650             if (message.getQuote().isPresent()) {
 651                 final var quote = message.getQuote().get();
 652
 653                 for (var quotedAttachment : quote.getAttachments()) {
 654                     final var thumbnail = quotedAttachment.getThumbnail();
 655                     if (thumbnail != null) {
 656                         context.getAttachmentHelper().downloadAttachment(thumbnail);
 657                     }
 658                 }
 659             }
 660         }
 661         if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) {
 662             final ProfileKey profileKey;
 663             try {
 664                 profileKey = new ProfileKey(message.getProfileKey().get());
 665             } catch (InvalidInputException e) {
 666                 throw new AssertionError(e);
 667             }
 668             if (account.getSelfRecipientId().equals(source)) {
 669                 this.account.setProfileKey(profileKey);
 670             }
 671             this.account.getProfileStore().storeProfileKey(source, profileKey);
 672         }
 673         if (message.getSticker().isPresent()) {
 674             final var messageSticker = message.getSticker().get();
 675             final var stickerPackId = StickerPackId.deserialize(messageSticker.getPackId());
 676             var sticker = account.getStickerStore().getStickerPack(stickerPackId);
 677             if (sticker == null) {
 678                 sticker = new Sticker(stickerPackId, messageSticker.getPackKey());
 679                 account.getStickerStore().updateSticker(sticker);
 680             }
 681             context.getJobExecutor().enqueueJob(new RetrieveStickerPackJob(stickerPackId, messageSticker.getPackKey()));
 682         }
 683         return actions;
 684     }
 685
 686     private Pair<RecipientId, Integer> getSender(SignalServiceEnvelope envelope, SignalServiceContent content) {
 687         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 688             return new Pair<>(context.getRecipientHelper().resolveRecipient(envelope.getSourceAddress()),
 689                     envelope.getSourceDevice());
 690         } else {
 691             return new Pair<>(context.getRecipientHelper().resolveRecipient(content.getSender()),
 692                     content.getSenderDevice());
 693         }
 694     }
 695 }