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
 264             actions.addAll(handleSignalServiceDataMessage(message,
 265                     false,
 266                     sender,
 267                     account.getSelfRecipientId(),
 268                     receiveConfig.ignoreAttachments()));
 269         }
 270
 271         if (content.getSyncMessage().isPresent()) {
 272             var syncMessage = content.getSyncMessage().get();
 273             actions.addAll(handleSyncMessage(syncMessage, sender, receiveConfig.ignoreAttachments()));
 274         }
 275
 276         return actions;
 277     }
 278
 279     private void handleDecryptionErrorMessage(
 280             final List<HandleAction> actions,
 281             final RecipientId sender,
 282             final int senderDeviceId,
 283             final DecryptionErrorMessage message
 284     ) {
 285         final var logEntries = account.getMessageSendLogStore()
 286                 .findMessages(sender, senderDeviceId, message.getTimestamp(), message.getRatchetKey().isEmpty());
 287
 288         for (final var logEntry : logEntries) {
 289             actions.add(new ResendMessageAction(sender, message.getTimestamp(), logEntry));
 290         }
 291
 292         if (message.getRatchetKey().isPresent()) {
 293             if (account.getSessionStore().isCurrentRatchetKey(sender, senderDeviceId, message.getRatchetKey().get())) {
 294                 if (logEntries.isEmpty()) {
 295                     logger.debug("Renewing the session with sender");
 296                     actions.add(new RenewSessionAction(sender));
 297                 } else {
 298                     logger.trace("Archiving the session with sender, a resend message has already been queued");
 299                     context.getAccount().getSessionStore().archiveSessions(sender);
 300                 }
 301             }
 302             return;
 303         }
 304
 305         var found = false;
 306         for (final var logEntry : logEntries) {
 307             if (logEntry.groupId().isEmpty()) {
 308                 continue;
 309             }
 310             final var group = account.getGroupStore().getGroup(logEntry.groupId().get());
 311             if (group == null) {
 312                 continue;
 313             }
 314             found = true;
 315             logger.trace("Deleting shared sender key with {} ({}): {}",
 316                     sender,
 317                     senderDeviceId,
 318                     group.getDistributionId());
 319             account.getSenderKeyStore().deleteSharedWith(sender, senderDeviceId, group.getDistributionId());
 320         }
 321         if (!found) {
 322             logger.debug("Reset all shared sender keys with this recipient, no related message found in send log");
 323             account.getSenderKeyStore().deleteSharedWith(sender);
 324         }
 325     }
 326
 327     private List<HandleAction> handleSyncMessage(
 328             final SignalServiceSyncMessage syncMessage, final RecipientId sender, final boolean ignoreAttachments
 329     ) {
 330         var actions = new ArrayList<HandleAction>();
 331         account.setMultiDevice(true);
 332         if (syncMessage.getSent().isPresent()) {
 333             var message = syncMessage.getSent().get();
 334             final var destination = message.getDestination().orElse(null);
 335             if (message.getDataMessage().isPresent()) {
 336                 actions.addAll(handleSignalServiceDataMessage(message.getDataMessage().get(),
 337                         true,
 338                         sender,
 339                         destination == null ? null : context.getRecipientHelper().resolveRecipient(destination),
 340                         ignoreAttachments));
 341             }
 342         }
 343         if (syncMessage.getRequest().isPresent() && account.isPrimaryDevice()) {
 344             var rm = syncMessage.getRequest().get();
 345             if (rm.isContactsRequest()) {
 346                 actions.add(SendSyncContactsAction.create());
 347             }
 348             if (rm.isGroupsRequest()) {
 349                 actions.add(SendSyncGroupsAction.create());
 350             }
 351             if (rm.isBlockedListRequest()) {
 352                 actions.add(SendSyncBlockedListAction.create());
 353             }
 354             if (rm.isKeysRequest()) {
 355                 actions.add(SendSyncKeysAction.create());
 356             }
 357             if (rm.isConfigurationRequest()) {
 358                 actions.add(SendSyncConfigurationAction.create());
 359             }
 360             if (rm.isPniIdentityRequest()) {
 361                 actions.add(SendPniIdentityKeyAction.create());
 362             }
 363         }
 364         if (syncMessage.getGroups().isPresent()) {
 365             logger.warn("Received a group v1 sync message, that can't be handled anymore, ignoring.");
 366         }
 367         if (syncMessage.getBlockedList().isPresent()) {
 368             final var blockedListMessage = syncMessage.getBlockedList().get();
 369             for (var address : blockedListMessage.getAddresses()) {
 370                 context.getContactHelper()
 371                         .setContactBlocked(context.getRecipientHelper().resolveRecipient(address), true);
 372             }
 373             for (var groupId : blockedListMessage.getGroupIds()
 374                     .stream()
 375                     .map(GroupId::unknownVersion)
 376                     .collect(Collectors.toSet())) {
 377                 try {
 378                     context.getGroupHelper().setGroupBlocked(groupId, true);
 379                 } catch (GroupNotFoundException e) {
 380                     logger.warn("BlockedListMessage contained groupID that was not found in GroupStore: {}",
 381                             groupId.toBase64());
 382                 }
 383             }
 384         }
 385         if (syncMessage.getContacts().isPresent()) {
 386             try {
 387                 final var contactsMessage = syncMessage.getContacts().get();
 388                 context.getAttachmentHelper()
 389                         .retrieveAttachment(contactsMessage.getContactsStream(),
 390                                 context.getSyncHelper()::handleSyncDeviceContacts);
 391             } catch (Exception e) {
 392                 logger.warn("Failed to handle received sync contacts, ignoring: {}", e.getMessage());
 393             }
 394         }
 395         if (syncMessage.getVerified().isPresent()) {
 396             final var verifiedMessage = syncMessage.getVerified().get();
 397             account.getIdentityKeyStore()
 398                     .setIdentityTrustLevel(account.getRecipientTrustedResolver()
 399                                     .resolveRecipientTrusted(verifiedMessage.getDestination()),
 400                             verifiedMessage.getIdentityKey(),
 401                             TrustLevel.fromVerifiedState(verifiedMessage.getVerified()));
 402         }
 403         if (syncMessage.getStickerPackOperations().isPresent()) {
 404             final var stickerPackOperationMessages = syncMessage.getStickerPackOperations().get();
 405             for (var m : stickerPackOperationMessages) {
 406                 if (m.getPackId().isEmpty()) {
 407                     continue;
 408                 }
 409                 final var stickerPackId = StickerPackId.deserialize(m.getPackId().get());
 410                 final var installed = m.getType().isEmpty()
 411                         || m.getType().get() == StickerPackOperationMessage.Type.INSTALL;
 412
 413                 var sticker = account.getStickerStore().getStickerPack(stickerPackId);
 414                 if (m.getPackKey().isPresent()) {
 415                     if (sticker == null) {
 416                         sticker = new Sticker(stickerPackId, m.getPackKey().get());
 417                     }
 418                     if (installed) {
 419                         context.getJobExecutor()
 420                                 .enqueueJob(new RetrieveStickerPackJob(stickerPackId, m.getPackKey().get()));
 421                     }
 422                 }
 423
 424                 if (sticker != null) {
 425                     sticker.setInstalled(installed);
 426                     account.getStickerStore().updateSticker(sticker);
 427                 }
 428             }
 429         }
 430         if (syncMessage.getFetchType().isPresent()) {
 431             switch (syncMessage.getFetchType().get()) {
 432                 case LOCAL_PROFILE:
 433                     actions.add(new RetrieveProfileAction(account.getSelfRecipientId()));
 434                 case STORAGE_MANIFEST:
 435                     actions.add(RetrieveStorageDataAction.create());
 436             }
 437         }
 438         if (syncMessage.getKeys().isPresent()) {
 439             final var keysMessage = syncMessage.getKeys().get();
 440             if (keysMessage.getStorageService().isPresent()) {
 441                 final var storageKey = keysMessage.getStorageService().get();
 442                 account.setStorageKey(storageKey);
 443                 actions.add(RetrieveStorageDataAction.create());
 444             }
 445         }
 446         if (syncMessage.getConfiguration().isPresent()) {
 447             final var configurationMessage = syncMessage.getConfiguration().get();
 448             final var configurationStore = account.getConfigurationStore();
 449             if (configurationMessage.getReadReceipts().isPresent()) {
 450                 configurationStore.setReadReceipts(configurationMessage.getReadReceipts().get());
 451             }
 452             if (configurationMessage.getLinkPreviews().isPresent()) {
 453                 configurationStore.setLinkPreviews(configurationMessage.getLinkPreviews().get());
 454             }
 455             if (configurationMessage.getTypingIndicators().isPresent()) {
 456                 configurationStore.setTypingIndicators(configurationMessage.getTypingIndicators().get());
 457             }
 458             if (configurationMessage.getUnidentifiedDeliveryIndicators().isPresent()) {
 459                 configurationStore.setUnidentifiedDeliveryIndicators(configurationMessage.getUnidentifiedDeliveryIndicators()
 460                         .get());
 461             }
 462         }
 463         if (syncMessage.getPniIdentity().isPresent()) {
 464             final var pniIdentity = syncMessage.getPniIdentity().get();
 465             account.setPniIdentityKeyPair(KeyUtils.getIdentityKeyPair(pniIdentity.getPublicKey().toByteArray(),
 466                     pniIdentity.getPrivateKey().toByteArray()));
 467             actions.add(RefreshPreKeysAction.create());
 468         }
 469         return actions;
 470     }
 471
 472     private boolean isMessageBlocked(SignalServiceEnvelope envelope, SignalServiceContent content) {
 473         SignalServiceAddress source;
 474         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 475             source = envelope.getSourceAddress();
 476         } else if (content != null) {
 477             source = content.getSender();
 478         } else {
 479             return false;
 480         }
 481         final var recipientId = context.getRecipientHelper().resolveRecipient(source);
 482         if (context.getContactHelper().isContactBlocked(recipientId)) {
 483             return true;
 484         }
 485
 486         if (content != null && content.getDataMessage().isPresent()) {
 487             var message = content.getDataMessage().get();
 488             if (message.getGroupContext().isPresent()) {
 489                 var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
 490                 return context.getGroupHelper().isGroupBlocked(groupId);
 491             }
 492         }
 493
 494         return false;
 495     }
 496
 497     private boolean isNotAllowedToSendToGroup(SignalServiceEnvelope envelope, SignalServiceContent content) {
 498         SignalServiceAddress source;
 499         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 500             source = envelope.getSourceAddress();
 501         } else if (content != null) {
 502             source = content.getSender();
 503         } else {
 504             return false;
 505         }
 506
 507         if (content == null || content.getDataMessage().isEmpty()) {
 508             return false;
 509         }
 510
 511         var message = content.getDataMessage().get();
 512         if (message.getGroupContext().isEmpty()) {
 513             return false;
 514         }
 515
 516         if (message.getGroupContext().get().getGroupV1().isPresent()) {
 517             var groupInfo = message.getGroupContext().get().getGroupV1().get();
 518             if (groupInfo.getType() == SignalServiceGroup.Type.QUIT) {
 519                 return false;
 520             }
 521         }
 522
 523         var groupId = GroupUtils.getGroupId(message.getGroupContext().get());
 524         var group = context.getGroupHelper().getGroup(groupId);
 525         if (group == null) {
 526             return false;
 527         }
 528
 529         final var recipientId = context.getRecipientHelper().resolveRecipient(source);
 530         if (!group.isMember(recipientId) && !(group.isPendingMember(recipientId) && message.isGroupV2Update())) {
 531             return true;
 532         }
 533
 534         if (group.isAnnouncementGroup() && !group.isAdmin(recipientId)) {
 535             return message.getBody().isPresent()
 536                     || message.getAttachments().isPresent()
 537                     || message.getQuote()
 538                     .isPresent()
 539                     || message.getPreviews().isPresent()
 540                     || message.getMentions().isPresent()
 541                     || message.getSticker().isPresent();
 542         }
 543         return false;
 544     }
 545
 546     private List<HandleAction> handleSignalServiceDataMessage(
 547             SignalServiceDataMessage message,
 548             boolean isSync,
 549             RecipientId source,
 550             RecipientId destination,
 551             boolean ignoreAttachments
 552     ) {
 553         var actions = new ArrayList<HandleAction>();
 554         if (message.getGroupContext().isPresent()) {
 555             if (message.getGroupContext().get().getGroupV1().isPresent()) {
 556                 var groupInfo = message.getGroupContext().get().getGroupV1().get();
 557                 var groupId = GroupId.v1(groupInfo.getGroupId());
 558                 var group = context.getGroupHelper().getGroup(groupId);
 559                 if (group == null || group instanceof GroupInfoV1) {
 560                     var groupV1 = (GroupInfoV1) group;
 561                     switch (groupInfo.getType()) {
 562                         case UPDATE: {
 563                             if (groupV1 == null) {
 564                                 groupV1 = new GroupInfoV1(groupId);
 565                             }
 566
 567                             if (groupInfo.getAvatar().isPresent()) {
 568                                 var avatar = groupInfo.getAvatar().get();
 569                                 context.getGroupHelper().downloadGroupAvatar(groupV1.getGroupId(), avatar);
 570                             }
 571
 572                             if (groupInfo.getName().isPresent()) {
 573                                 groupV1.name = groupInfo.getName().get();
 574                             }
 575
 576                             if (groupInfo.getMembers().isPresent()) {
 577                                 groupV1.addMembers(groupInfo.getMembers()
 578                                         .get()
 579                                         .stream()
 580                                         .map(context.getRecipientHelper()::resolveRecipient)
 581                                         .collect(Collectors.toSet()));
 582                             }
 583
 584                             account.getGroupStore().updateGroup(groupV1);
 585                             break;
 586                         }
 587                         case DELIVER:
 588                             if (groupV1 == null && !isSync) {
 589                                 actions.add(new SendGroupInfoRequestAction(source, groupId));
 590                             }
 591                             break;
 592                         case QUIT: {
 593                             if (groupV1 != null) {
 594                                 groupV1.removeMember(source);
 595                                 account.getGroupStore().updateGroup(groupV1);
 596                             }
 597                             break;
 598                         }
 599                         case REQUEST_INFO:
 600                             if (groupV1 != null && !isSync) {
 601                                 actions.add(new SendGroupInfoAction(source, groupV1.getGroupId()));
 602                             }
 603                             break;
 604                     }
 605                 } else {
 606                     // Received a group v1 message for a v2 group
 607                 }
 608             }
 609             if (message.getGroupContext().get().getGroupV2().isPresent()) {
 610                 final var groupContext = message.getGroupContext().get().getGroupV2().get();
 611                 final var groupMasterKey = groupContext.getMasterKey();
 612
 613                 context.getGroupHelper()
 614                         .getOrMigrateGroup(groupMasterKey,
 615                                 groupContext.getRevision(),
 616                                 groupContext.hasSignedGroupChange() ? groupContext.getSignedGroupChange() : null);
 617             }
 618         }
 619
 620         final var conversationPartnerAddress = isSync ? destination : source;
 621         if (conversationPartnerAddress != null && message.isEndSession()) {
 622             account.getSessionStore().deleteAllSessions(conversationPartnerAddress);
 623         }
 624         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
 625             if (message.getGroupContext().isPresent()) {
 626                 if (message.getGroupContext().get().getGroupV1().isPresent()) {
 627                     var groupInfo = message.getGroupContext().get().getGroupV1().get();
 628                     var group = account.getGroupStore().getOrCreateGroupV1(GroupId.v1(groupInfo.getGroupId()));
 629                     if (group != null) {
 630                         if (group.messageExpirationTime != message.getExpiresInSeconds()) {
 631                             group.messageExpirationTime = message.getExpiresInSeconds();
 632                             account.getGroupStore().updateGroup(group);
 633                         }
 634                     }
 635                 } else if (message.getGroupContext().get().getGroupV2().isPresent()) {
 636                     // disappearing message timer already stored in the DecryptedGroup
 637                 }
 638             } else if (conversationPartnerAddress != null) {
 639                 context.getContactHelper()
 640                         .setExpirationTimer(conversationPartnerAddress, message.getExpiresInSeconds());
 641             }
 642         }
 643         if (!ignoreAttachments) {
 644             if (message.getAttachments().isPresent()) {
 645                 for (var attachment : message.getAttachments().get()) {
 646                     context.getAttachmentHelper().downloadAttachment(attachment);
 647                 }
 648             }
 649             if (message.getSharedContacts().isPresent()) {
 650                 for (var contact : message.getSharedContacts().get()) {
 651                     if (contact.getAvatar().isPresent()) {
 652                         context.getAttachmentHelper().downloadAttachment(contact.getAvatar().get().getAttachment());
 653                     }
 654                 }
 655             }
 656             if (message.getPreviews().isPresent()) {
 657                 final var previews = message.getPreviews().get();
 658                 for (var preview : previews) {
 659                     if (preview.getImage().isPresent()) {
 660                         context.getAttachmentHelper().downloadAttachment(preview.getImage().get());
 661                     }
 662                 }
 663             }
 664             if (message.getQuote().isPresent()) {
 665                 final var quote = message.getQuote().get();
 666
 667                 for (var quotedAttachment : quote.getAttachments()) {
 668                     final var thumbnail = quotedAttachment.getThumbnail();
 669                     if (thumbnail != null) {
 670                         context.getAttachmentHelper().downloadAttachment(thumbnail);
 671                     }
 672                 }
 673             }
 674         }
 675         if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) {
 676             final ProfileKey profileKey;
 677             try {
 678                 profileKey = new ProfileKey(message.getProfileKey().get());
 679             } catch (InvalidInputException e) {
 680                 throw new AssertionError(e);
 681             }
 682             if (account.getSelfRecipientId().equals(source)) {
 683                 this.account.setProfileKey(profileKey);
 684             }
 685             this.account.getProfileStore().storeProfileKey(source, profileKey);
 686         }
 687         if (message.getSticker().isPresent()) {
 688             final var messageSticker = message.getSticker().get();
 689             final var stickerPackId = StickerPackId.deserialize(messageSticker.getPackId());
 690             var sticker = account.getStickerStore().getStickerPack(stickerPackId);
 691             if (sticker == null) {
 692                 sticker = new Sticker(stickerPackId, messageSticker.getPackKey());
 693                 account.getStickerStore().updateSticker(sticker);
 694             }
 695             context.getJobExecutor().enqueueJob(new RetrieveStickerPackJob(stickerPackId, messageSticker.getPackKey()));
 696         }
 697         return actions;
 698     }
 699
 700     private Pair<RecipientId, Integer> getSender(SignalServiceEnvelope envelope, SignalServiceContent content) {
 701         if (!envelope.isUnidentifiedSender() && envelope.hasSourceUuid()) {
 702             return new Pair<>(context.getRecipientHelper().resolveRecipient(envelope.getSourceAddress()),
 703                     envelope.getSourceDevice());
 704         } else {
 705             return new Pair<>(context.getRecipientHelper().resolveRecipient(content.getSender()),
 706                     content.getSenderDevice());
 707         }
 708     }
 709 }