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