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