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.RecipientAddress;
  35 import org.asamk.signal.manager.storage.recipients.RecipientId;
  36 import org.asamk.signal.manager.storage.stickers.StickerPack;
  37 import org.signal.libsignal.metadata.ProtocolInvalidKeyException;
  38 import org.signal.libsignal.metadata.ProtocolInvalidKeyIdException;
  39 import org.signal.libsignal.metadata.ProtocolInvalidMessageException;
  40 import org.signal.libsignal.metadata.ProtocolNoSessionException;
  41 import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException;
  42 import org.signal.libsignal.metadata.SelfSendException;
  43 import org.signal.libsignal.protocol.InvalidMessageException;
  44 import org.signal.libsignal.protocol.groups.GroupSessionBuilder;
  45 import org.signal.libsignal.protocol.message.DecryptionErrorMessage;
  46 import org.signal.libsignal.zkgroup.InvalidInputException;
  47 import org.signal.libsignal.zkgroup.profiles.ProfileKey;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50 import org.whispersystems.signalservice.api.InvalidMessageStructureException;
  51 import org.whispersystems.signalservice.api.crypto.SignalGroupSessionBuilder;
  52 import org.whispersystems.signalservice.api.crypto.SignalServiceCipherResult;
  53 import org.whispersystems.signalservice.api.messages.EnvelopeContentValidator;
  54 import org.whispersystems.signalservice.api.messages.SignalServiceContent;
  55 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
  56 import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
  57 import org.whispersystems.signalservice.api.messages.SignalServiceGroup;
  58 import org.whispersystems.signalservice.api.messages.SignalServiceGroupContext;
  59 import org.whispersystems.signalservice.api.messages.SignalServiceGroupV2;
  60 import org.whispersystems.signalservice.api.messages.SignalServicePniSignatureMessage;
  61 import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
  62 import org.whispersystems.signalservice.api.messages.SignalServiceStoryMessage;
  63 import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
  64 import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage;
  65 import org.whispersystems.signalservice.api.push.ServiceId;
  66 import org.whispersystems.signalservice.api.push.ServiceId.ACI;
  67 import org.whispersystems.signalservice.api.push.ServiceIdType;
  68 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  69 import org.whispersystems.signalservice.internal.push.Envelope;
  70 import org.whispersystems.signalservice.internal.push.UnsupportedDataMessageException;
  71
  72 import java.util.ArrayList;
  73 import java.util.List;
  74 import java.util.Optional;
  75 import java.util.stream.Collectors;
  76
  77 public final class IncomingMessageHandler {
  78
  79     private static final Logger logger = LoggerFactory.getLogger(IncomingMessageHandler.class);
  80
  81     private final SignalAccount account;
  82     private final SignalDependencies dependencies;
  83     private final Context context;
  84
  85     public IncomingMessageHandler(final Context context) {
  86         this.account = context.getAccount();
  87         this.dependencies = context.getDependencies();
  88         this.context = context;
  89     }
  90
  91     public Pair<List<HandleAction>, Exception> handleRetryEnvelope(
  92             final SignalServiceEnvelope envelope,
  93             final ReceiveConfig receiveConfig,
  94             final Manager.ReceiveMessageHandler handler
  95     ) {
  96         final List<HandleAction> actions = new ArrayList<>();
  97         if (envelope.isPreKeySignalMessage()) {
  98             actions.add(RefreshPreKeysAction.create());
  99         }
 100
 101         SignalServiceContent content = null;
 102         if (!envelope.isReceipt()) {
 103             account.getIdentityKeyStore().setRetryingDecryption(true);
 104             final var destination = getDestination(envelope).serviceId();
 105             try {
 106                 final var cipherResult = dependencies.getCipher(destination == null
 107                                 || destination.equals(account.getAci()) ? ServiceIdType.ACI : ServiceIdType.PNI)
 108                         .decrypt(envelope.getProto(), envelope.getServerDeliveredTimestamp());
 109                 content = validate(envelope.getProto(), cipherResult, envelope.getServerDeliveredTimestamp());
 110                 if (content == null) {
 111                     return new Pair<>(List.of(), null);
 112                 }
 113             } catch (ProtocolUntrustedIdentityException e) {
 114                 final var recipientId = account.getRecipientResolver().resolveRecipient(e.getSender());
 115                 final var exception = new UntrustedIdentityException(account.getRecipientAddressResolver()
 116                         .resolveRecipientAddress(recipientId)
 117                         .toApiRecipientAddress(), e.getSenderDevice());
 118                 return new Pair<>(List.of(), exception);
 119             } catch (Exception e) {
 120                 return new Pair<>(List.of(), e);
 121             } finally {
 122                 account.getIdentityKeyStore().setRetryingDecryption(false);
 123             }
 124         }
 125         actions.addAll(checkAndHandleMessage(envelope, content, receiveConfig, handler, null));
 126         return new Pair<>(actions, null);
 127     }
 128
 129     public Pair<List<HandleAction>, Exception> handleEnvelope(
 130             final SignalServiceEnvelope envelope,
 131             final ReceiveConfig receiveConfig,
 132             final Manager.ReceiveMessageHandler handler
 133     ) {
 134         final var actions = new ArrayList<HandleAction>();
 135         SignalServiceContent content = null;
 136         Exception exception = null;
 137         envelope.getSourceServiceId().map(ServiceId::parseOrNull)
 138                 // Store uuid if we don't have it already
 139                 // uuid in envelope is sent by server
 140                 .ifPresent(serviceId -> account.getRecipientResolver().resolveRecipient(serviceId));
 141         if (!envelope.isReceipt()) {
 142             final var destination = getDestination(envelope).serviceId();
 143             try {
 144                 final var cipherResult = dependencies.getCipher(destination == null
 145                                 || destination.equals(account.getAci()) ? ServiceIdType.ACI : ServiceIdType.PNI)
 146                         .decrypt(envelope.getProto(), envelope.getServerDeliveredTimestamp());
 147                 content = validate(envelope.getProto(), cipherResult, envelope.getServerDeliveredTimestamp());
 148                 if (content == null) {
 149                     return new Pair<>(List.of(), null);
 150                 }
 151             } catch (ProtocolUntrustedIdentityException e) {
 152                 final var recipientId = account.getRecipientResolver().resolveRecipient(e.getSender());
 153                 actions.add(new RetrieveProfileAction(recipientId));
 154                 exception = new UntrustedIdentityException(account.getRecipientAddressResolver()
 155                         .resolveRecipientAddress(recipientId)
 156                         .toApiRecipientAddress(), e.getSenderDevice());
 157             } catch (ProtocolInvalidKeyIdException | ProtocolInvalidKeyException | ProtocolNoSessionException |
 158                      ProtocolInvalidMessageException e) {
 159                 logger.debug("Failed to decrypt incoming message", e);
 160                 final var sender = account.getRecipientResolver().resolveRecipient(e.getSender());
 161                 if (context.getContactHelper().isContactBlocked(sender)) {
 162                     logger.debug("Received invalid message from blocked contact, ignoring.");
 163                 } else {
 164                     var serviceId = ServiceId.parseOrNull(e.getSender());
 165                     if (serviceId != null) {
 166                         final var isSelf = sender.equals(account.getSelfRecipientId())
 167                                 && e.getSenderDevice() == account.getDeviceId();
 168                         logger.debug("Received invalid message, queuing renew session action.");
 169                         actions.add(new RenewSessionAction(sender, serviceId, destination));
 170                         if (!isSelf) {
 171                             logger.debug("Received invalid message, requesting message resend.");
 172                             actions.add(new SendRetryMessageRequestAction(sender, e, envelope));
 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 individual : blockedListMessage.individuals) {
 529                 final var address = new RecipientAddress(individual.getAci(), individual.getE164());
 530                 final var recipientId = account.getRecipientResolver().resolveRecipient(address);
 531                 context.getContactHelper().setContactBlocked(recipientId, true);
 532             }
 533             for (var groupId : blockedListMessage.groupIds.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.getAccountEntropyPool() != null) {
 589                 final var aep = keysMessage.getAccountEntropyPool();
 590                 account.setAccountEntropyPool(aep);
 591                 actions.add(SyncStorageDataAction.create());
 592             } else if (keysMessage.getMaster() != null) {
 593                 final var masterKey = keysMessage.getMaster();
 594                 account.setMasterKey(masterKey);
 595                 actions.add(SyncStorageDataAction.create());
 596             } else if (keysMessage.getStorageService() != null) {
 597                 final var storageKey = keysMessage.getStorageService();
 598                 account.setStorageKey(storageKey);
 599                 actions.add(SyncStorageDataAction.create());
 600             }
 601             if (keysMessage.getMediaRootBackupKey() != null) {
 602                 final var mrb = keysMessage.getMediaRootBackupKey();
 603                 account.setMediaRootBackupKey(mrb);
 604                 actions.add(SyncStorageDataAction.create());
 605             }
 606         }
 607         if (syncMessage.getConfiguration().isPresent()) {
 608             final var configurationMessage = syncMessage.getConfiguration().get();
 609             final var configurationStore = account.getConfigurationStore();
 610             if (configurationMessage.getReadReceipts().isPresent()) {
 611                 configurationStore.setReadReceipts(configurationMessage.getReadReceipts().get());
 612             }
 613             if (configurationMessage.getLinkPreviews().isPresent()) {
 614                 configurationStore.setLinkPreviews(configurationMessage.getLinkPreviews().get());
 615             }
 616             if (configurationMessage.getTypingIndicators().isPresent()) {
 617                 configurationStore.setTypingIndicators(configurationMessage.getTypingIndicators().get());
 618             }
 619             if (configurationMessage.getUnidentifiedDeliveryIndicators().isPresent()) {
 620                 configurationStore.setUnidentifiedDeliveryIndicators(configurationMessage.getUnidentifiedDeliveryIndicators()
 621                         .get());
 622             }
 623         }
 624         if (syncMessage.getPniChangeNumber().isPresent()) {
 625             final var pniChangeNumber = syncMessage.getPniChangeNumber().get();
 626             logger.debug("Received PNI change number sync message, applying.");
 627             final var updatedPniString = envelope.getUpdatedPni();
 628             if (updatedPniString != null && !updatedPniString.isEmpty()) {
 629                 final var updatedPni = ServiceId.PNI.parseOrThrow(updatedPniString);
 630                 context.getAccountHelper().handlePniChangeNumberMessage(pniChangeNumber, updatedPni);
 631             }
 632         }
 633         return actions;
 634     }
 635
 636     private SignalServiceGroupContext getGroupContext(SignalServiceContent content) {
 637         if (content == null) {
 638             return null;
 639         }
 640
 641         if (content.getDataMessage().isPresent()) {
 642             var message = content.getDataMessage().get();
 643             if (message.getGroupContext().isPresent()) {
 644                 return message.getGroupContext().get();
 645             }
 646         }
 647
 648         if (content.getStoryMessage().isPresent()) {
 649             var message = content.getStoryMessage().get();
 650             if (message.getGroupContext().isPresent()) {
 651                 try {
 652                     return SignalServiceGroupContext.create(null, message.getGroupContext().get());
 653                 } catch (InvalidMessageException e) {
 654                     throw new AssertionError(e);
 655                 }
 656             }
 657         }
 658
 659         return null;
 660     }
 661
 662     private boolean isMessageBlocked(SignalServiceEnvelope envelope, SignalServiceContent content) {
 663         SignalServiceAddress source = getSenderAddress(envelope, content);
 664         if (source == null) {
 665             return false;
 666         }
 667         final var recipientId = account.getRecipientResolver().resolveRecipient(source);
 668         if (context.getContactHelper().isContactBlocked(recipientId)) {
 669             return true;
 670         }
 671
 672         final var groupContext = getGroupContext(content);
 673         if (groupContext != null) {
 674             var groupId = GroupUtils.getGroupId(groupContext);
 675             return context.getGroupHelper().isGroupBlocked(groupId);
 676         }
 677
 678         return false;
 679     }
 680
 681     private boolean isNotAllowedToSendToGroup(SignalServiceEnvelope envelope, SignalServiceContent content) {
 682         SignalServiceAddress source = getSenderAddress(envelope, content);
 683         if (source == null) {
 684             return false;
 685         }
 686
 687         final var groupContext = getGroupContext(content);
 688         if (groupContext == null) {
 689             return false;
 690         }
 691
 692         if (groupContext.getGroupV1().isPresent()) {
 693             var groupInfo = groupContext.getGroupV1().get();
 694             if (groupInfo.getType() == SignalServiceGroup.Type.QUIT) {
 695                 return false;
 696             }
 697         }
 698
 699         var groupId = GroupUtils.getGroupId(groupContext);
 700         var group = context.getGroupHelper().getGroup(groupId);
 701         if (group == null) {
 702             return false;
 703         }
 704
 705         final var message = content.getDataMessage().orElse(null);
 706
 707         final var recipientId = account.getRecipientResolver().resolveRecipient(source);
 708         if (!group.isMember(recipientId) && !(
 709                 group.isPendingMember(recipientId) && message != null && message.isGroupV2Update()
 710         )) {
 711             return true;
 712         }
 713
 714         if (group.isAnnouncementGroup() && !group.isAdmin(recipientId)) {
 715             return message == null
 716                     || message.getBody().isPresent()
 717                     || message.getAttachments().isPresent()
 718                     || message.getQuote().isPresent()
 719                     || message.getPreviews().isPresent()
 720                     || message.getMentions().isPresent()
 721                     || message.getSticker().isPresent();
 722         }
 723         return false;
 724     }
 725
 726     private List<HandleAction> handleSignalServiceDataMessage(
 727             SignalServiceDataMessage message,
 728             boolean isSync,
 729             DeviceAddress source,
 730             DeviceAddress destination,
 731             boolean ignoreAttachments
 732     ) {
 733         var actions = new ArrayList<HandleAction>();
 734         if (message.getGroupContext().isPresent()) {
 735             final var groupContext = message.getGroupContext().get();
 736             if (groupContext.getGroupV1().isPresent()) {
 737                 var groupInfo = groupContext.getGroupV1().get();
 738                 var groupId = GroupId.v1(groupInfo.getGroupId());
 739                 var group = context.getGroupHelper().getGroup(groupId);
 740                 if (group == null || group instanceof GroupInfoV1) {
 741                     var groupV1 = (GroupInfoV1) group;
 742                     switch (groupInfo.getType()) {
 743                         case UPDATE -> {
 744                             if (groupV1 == null) {
 745                                 groupV1 = new GroupInfoV1(groupId);
 746                             }
 747
 748                             if (groupInfo.getAvatar().isPresent()) {
 749                                 var avatar = groupInfo.getAvatar().get();
 750                                 context.getGroupHelper().downloadGroupAvatar(groupV1.getGroupId(), avatar);
 751                             }
 752
 753                             if (groupInfo.getName().isPresent()) {
 754                                 groupV1.name = groupInfo.getName().get();
 755                             }
 756
 757                             if (groupInfo.getMembers().isPresent()) {
 758                                 final var recipientResolver = account.getRecipientResolver();
 759                                 groupV1.addMembers(groupInfo.getMembers()
 760                                         .get()
 761                                         .stream()
 762                                         .map(recipientResolver::resolveRecipient)
 763                                         .collect(Collectors.toSet()));
 764                             }
 765
 766                             account.getGroupStore().updateGroup(groupV1);
 767                         }
 768                         case DELIVER -> {
 769                             if (groupV1 == null && !isSync) {
 770                                 actions.add(new SendGroupInfoRequestAction(source.recipientId(), groupId));
 771                             }
 772                         }
 773                         case QUIT -> {
 774                             if (groupV1 != null) {
 775                                 groupV1.removeMember(source.recipientId());
 776                                 account.getGroupStore().updateGroup(groupV1);
 777                             }
 778                         }
 779                         case REQUEST_INFO -> {
 780                             if (groupV1 != null && !isSync) {
 781                                 actions.add(new SendGroupInfoAction(source.recipientId(), groupV1.getGroupId()));
 782                             }
 783                         }
 784                     }
 785                 } else {
 786                     // Received a group v1 message for a v2 group
 787                 }
 788             }
 789             if (groupContext.getGroupV2().isPresent()) {
 790                 handleGroupV2Context(groupContext.getGroupV2().get());
 791             }
 792         }
 793
 794         final var selfAddress = isSync ? source : destination;
 795         final var conversationPartnerAddress = isSync ? destination : source;
 796         if (conversationPartnerAddress != null && message.isEndSession()) {
 797             account.getAccountData(selfAddress.serviceId())
 798                     .getSessionStore()
 799                     .deleteAllSessions(conversationPartnerAddress.serviceId());
 800         }
 801         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
 802             if (message.getGroupContext().isPresent()) {
 803                 final var groupContext = message.getGroupContext().get();
 804                 if (groupContext.getGroupV1().isPresent()) {
 805                     var groupInfo = groupContext.getGroupV1().get();
 806                     var group = account.getGroupStore().getOrCreateGroupV1(GroupId.v1(groupInfo.getGroupId()));
 807                     if (group != null) {
 808                         if (group.messageExpirationTime != message.getExpiresInSeconds()) {
 809                             group.messageExpirationTime = message.getExpiresInSeconds();
 810                             account.getGroupStore().updateGroup(group);
 811                         }
 812                     }
 813                 } else if (groupContext.getGroupV2().isPresent()) {
 814                     // disappearing message timer already stored in the DecryptedGroup
 815                 }
 816             } else if (conversationPartnerAddress != null) {
 817                 context.getContactHelper()
 818                         .setExpirationTimer(conversationPartnerAddress.recipientId(),
 819                                 message.getExpiresInSeconds(),
 820                                 message.getExpireTimerVersion());
 821             }
 822         }
 823         if (!ignoreAttachments) {
 824             if (message.getAttachments().isPresent()) {
 825                 for (var attachment : message.getAttachments().get()) {
 826                     context.getAttachmentHelper().downloadAttachment(attachment);
 827                 }
 828             }
 829             if (message.getSharedContacts().isPresent()) {
 830                 for (var contact : message.getSharedContacts().get()) {
 831                     if (contact.getAvatar().isPresent()) {
 832                         context.getAttachmentHelper().downloadAttachment(contact.getAvatar().get().getAttachment());
 833                     }
 834                 }
 835             }
 836             if (message.getPreviews().isPresent()) {
 837                 final var previews = message.getPreviews().get();
 838                 for (var preview : previews) {
 839                     if (preview.getImage().isPresent()) {
 840                         context.getAttachmentHelper().downloadAttachment(preview.getImage().get());
 841                     }
 842                 }
 843             }
 844             if (message.getQuote().isPresent()) {
 845                 final var quote = message.getQuote().get();
 846
 847                 if (quote.getAttachments() != null) {
 848                     for (var quotedAttachment : quote.getAttachments()) {
 849                         final var thumbnail = quotedAttachment.getThumbnail();
 850                         if (thumbnail != null) {
 851                             context.getAttachmentHelper().downloadAttachment(thumbnail);
 852                         }
 853                     }
 854                 }
 855             }
 856         }
 857         if (message.getGiftBadge().isPresent()) {
 858             handleIncomingGiftBadge(message.getGiftBadge().get());
 859         }
 860         if (message.getProfileKey().isPresent()) {
 861             handleIncomingProfileKey(message.getProfileKey().get(), source.recipientId());
 862         }
 863         if (message.getSticker().isPresent()) {
 864             final var messageSticker = message.getSticker().get();
 865             final var stickerPackId = StickerPackId.deserialize(messageSticker.getPackId());
 866             var sticker = account.getStickerStore().getStickerPack(stickerPackId);
 867             if (sticker == null) {
 868                 sticker = new StickerPack(stickerPackId, messageSticker.getPackKey());
 869                 account.getStickerStore().addStickerPack(sticker);
 870             }
 871             context.getJobExecutor().enqueueJob(new RetrieveStickerPackJob(stickerPackId, messageSticker.getPackKey()));
 872         }
 873         return actions;
 874     }
 875
 876     private void handleIncomingGiftBadge(final SignalServiceDataMessage.GiftBadge giftBadge) {
 877         // TODO
 878     }
 879
 880     private List<HandleAction> handleSignalServiceStoryMessage(
 881             SignalServiceStoryMessage message,
 882             RecipientId source,
 883             boolean ignoreAttachments
 884     ) {
 885         var actions = new ArrayList<HandleAction>();
 886         if (message.getGroupContext().isPresent()) {
 887             handleGroupV2Context(message.getGroupContext().get());
 888         }
 889
 890         if (!ignoreAttachments) {
 891             if (message.getFileAttachment().isPresent()) {
 892                 context.getAttachmentHelper().downloadAttachment(message.getFileAttachment().get());
 893             }
 894             if (message.getTextAttachment().isPresent()) {
 895                 final var textAttachment = message.getTextAttachment().get();
 896                 if (textAttachment.getPreview().isPresent()) {
 897                     final var preview = textAttachment.getPreview().get();
 898                     if (preview.getImage().isPresent()) {
 899                         context.getAttachmentHelper().downloadAttachment(preview.getImage().get());
 900                     }
 901                 }
 902             }
 903         }
 904
 905         if (message.getProfileKey().isPresent()) {
 906             handleIncomingProfileKey(message.getProfileKey().get(), source);
 907         }
 908
 909         return actions;
 910     }
 911
 912     private void handleGroupV2Context(final SignalServiceGroupV2 groupContext) {
 913         final var groupMasterKey = groupContext.getMasterKey();
 914
 915         context.getGroupHelper()
 916                 .getOrMigrateGroup(groupMasterKey,
 917                         groupContext.getRevision(),
 918                         groupContext.hasSignedGroupChange() ? groupContext.getSignedGroupChange() : null);
 919     }
 920
 921     private void handleIncomingProfileKey(final byte[] profileKeyBytes, final RecipientId source) {
 922         if (profileKeyBytes.length != 32) {
 923             logger.debug("Received invalid profile key of length {}", profileKeyBytes.length);
 924             return;
 925         }
 926         final ProfileKey profileKey;
 927         try {
 928             profileKey = new ProfileKey(profileKeyBytes);
 929         } catch (InvalidInputException e) {
 930             throw new AssertionError(e);
 931         }
 932         if (account.getSelfRecipientId().equals(source)) {
 933             this.account.setProfileKey(profileKey);
 934         }
 935         this.account.getProfileStore().storeProfileKey(source, profileKey);
 936     }
 937
 938     private SignalServiceAddress getSenderAddress(SignalServiceEnvelope envelope, SignalServiceContent content) {
 939         final var serviceId = envelope.getSourceServiceId().map(ServiceId::parseOrNull).orElse(null);
 940         if (!envelope.isUnidentifiedSender() && serviceId != null) {
 941             return new SignalServiceAddress(serviceId);
 942         } else if (content != null) {
 943             return content.getSender();
 944         } else {
 945             return null;
 946         }
 947     }
 948
 949     private DeviceAddress getSender(SignalServiceEnvelope envelope, SignalServiceContent content) {
 950         final var serviceId = envelope.getSourceServiceId().map(ServiceId::parseOrNull).orElse(null);
 951         if (!envelope.isUnidentifiedSender() && serviceId != null) {
 952             return new DeviceAddress(account.getRecipientResolver().resolveRecipient(serviceId),
 953                     serviceId,
 954                     envelope.getSourceDevice());
 955         } else {
 956             return new DeviceAddress(account.getRecipientResolver().resolveRecipient(content.getSender()),
 957                     content.getSender().getServiceId(),
 958                     content.getSenderDevice());
 959         }
 960     }
 961
 962     private DeviceAddress getDestination(SignalServiceEnvelope envelope) {
 963         final var destination = envelope.getDestinationServiceId();
 964         if (destination == null || destination.isUnknown()) {
 965             return new DeviceAddress(account.getSelfRecipientId(), account.getAci(), account.getDeviceId());
 966         }
 967         return new DeviceAddress(account.getRecipientResolver().resolveRecipient(destination),
 968                 destination,
 969                 account.getDeviceId());
 970     }
 971
 972     private record DeviceAddress(RecipientId recipientId, ServiceId serviceId, int deviceId) {}
 973 }