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