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