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