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