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