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