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