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