nmode's Git Repositories - signal-cli/blob - lib/src/main/java/org/asamk/signal/manager/helper/RecipientHelper.java

   1 package org.asamk.signal.manager.helper;
   2
   3 import org.asamk.signal.manager.SignalDependencies;
   4 import org.asamk.signal.manager.api.RecipientIdentifier;
   5 import org.asamk.signal.manager.api.UnregisteredRecipientException;
   6 import org.asamk.signal.manager.config.ServiceConfig;
   7 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
   8 import org.asamk.signal.manager.storage.SignalAccount;
   9 import org.asamk.signal.manager.storage.recipients.RecipientAddress;
  10 import org.asamk.signal.manager.storage.recipients.RecipientId;
  11 import org.signal.libsignal.protocol.InvalidKeyException;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14 import org.whispersystems.signalservice.api.push.ACI;
  15 import org.whispersystems.signalservice.api.push.ServiceId;
  16 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  17 import org.whispersystems.signalservice.internal.contacts.crypto.Quote;
  18 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedQuoteException;
  19 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException;
  20
  21 import java.io.IOException;
  22 import java.security.SignatureException;
  23 import java.util.Collection;
  24 import java.util.HashSet;
  25 import java.util.Map;
  26 import java.util.Set;
  27
  28 public class RecipientHelper {
  29
  30     private final static Logger logger = LoggerFactory.getLogger(RecipientHelper.class);
  31
  32     private final SignalAccount account;
  33     private final SignalDependencies dependencies;
  34     private final ServiceEnvironmentConfig serviceEnvironmentConfig;
  35
  36     public RecipientHelper(final Context context) {
  37         this.account = context.getAccount();
  38         this.dependencies = context.getDependencies();
  39         this.serviceEnvironmentConfig = dependencies.getServiceEnvironmentConfig();
  40     }
  41
  42     public SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) {
  43         final var address = account.getRecipientStore().resolveRecipientAddress(recipientId);
  44         if (address.number().isEmpty() || address.uuid().isPresent()) {
  45             return address.toSignalServiceAddress();
  46         }
  47
  48         // Address in recipient store doesn't have a uuid, this shouldn't happen
  49         // Try to retrieve the uuid from the server
  50         final var number = address.number().get();
  51         final ACI aci;
  52         try {
  53             aci = getRegisteredUser(number);
  54         } catch (UnregisteredRecipientException | IOException e) {
  55             logger.warn("Failed to get uuid for e164 number: {}", number, e);
  56             // Return SignalServiceAddress with unknown UUID
  57             return address.toSignalServiceAddress();
  58         }
  59         return account.getRecipientStore()
  60                 .resolveRecipientAddress(account.getRecipientStore().resolveRecipient(aci))
  61                 .toSignalServiceAddress();
  62     }
  63
  64     public RecipientId resolveRecipient(final SignalServiceAddress address) {
  65         return account.getRecipientStore().resolveRecipient(address);
  66     }
  67
  68     public Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws IOException, UnregisteredRecipientException {
  69         final var recipientIds = new HashSet<RecipientId>(recipients.size());
  70         for (var number : recipients) {
  71             final var recipientId = resolveRecipient(number);
  72             recipientIds.add(recipientId);
  73         }
  74         return recipientIds;
  75     }
  76
  77     public RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
  78         if (recipient instanceof RecipientIdentifier.Uuid uuidRecipient) {
  79             return account.getRecipientStore().resolveRecipient(ServiceId.from(uuidRecipient.uuid()));
  80         } else {
  81             final var number = ((RecipientIdentifier.Number) recipient).number();
  82             return account.getRecipientStore().resolveRecipient(number, () -> {
  83                 try {
  84                     return getRegisteredUser(number);
  85                 } catch (Exception e) {
  86                     return null;
  87                 }
  88             });
  89         }
  90     }
  91
  92     public RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException, UnregisteredRecipientException {
  93         final var address = resolveSignalServiceAddress(recipientId);
  94         if (address.getNumber().isEmpty()) {
  95             return recipientId;
  96         }
  97         final var number = address.getNumber().get();
  98         final var uuid = getRegisteredUser(number);
  99         return account.getRecipientStore().resolveRecipientTrusted(new SignalServiceAddress(uuid, number));
 100     }
 101
 102     public Map<String, ACI> getRegisteredUsers(final Set<String> numbers) throws IOException {
 103         final Map<String, ACI> registeredUsers;
 104         try {
 105             registeredUsers = dependencies.getAccountManager()
 106                     .getRegisteredUsers(ServiceConfig.getIasKeyStore(),
 107                             numbers,
 108                             serviceEnvironmentConfig.getCdsMrenclave());
 109         } catch (Quote.InvalidQuoteFormatException | UnauthenticatedQuoteException | SignatureException | UnauthenticatedResponseException | InvalidKeyException | NumberFormatException e) {
 110             throw new IOException(e);
 111         }
 112
 113         // Store numbers as recipients, so we have the number/uuid association
 114         registeredUsers.forEach((number, aci) -> account.getRecipientStore()
 115                 .resolveRecipientTrusted(new SignalServiceAddress(aci, number)));
 116
 117         return registeredUsers;
 118     }
 119
 120     private ACI getRegisteredUser(final String number) throws IOException, UnregisteredRecipientException {
 121         final Map<String, ACI> aciMap;
 122         try {
 123             aciMap = getRegisteredUsers(Set.of(number));
 124         } catch (NumberFormatException e) {
 125             throw new UnregisteredRecipientException(new RecipientAddress(null, number));
 126         }
 127         final var uuid = aciMap.get(number);
 128         if (uuid == null) {
 129             throw new UnregisteredRecipientException(new RecipientAddress(null, number));
 130         }
 131         return uuid;
 132     }
 133 }