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