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.RecipientId;
  10 import org.signal.libsignal.protocol.InvalidKeyException;
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13 import org.whispersystems.signalservice.api.push.ACI;
  14 import org.whispersystems.signalservice.api.push.PNI;
  15 import org.whispersystems.signalservice.api.push.ServiceId;
  16 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  17 import org.whispersystems.signalservice.api.services.CdsiV2Service;
  18 import org.whispersystems.signalservice.internal.contacts.crypto.Quote;
  19 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedQuoteException;
  20 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException;
  21
  22 import java.io.IOException;
  23 import java.security.SignatureException;
  24 import java.util.Collection;
  25 import java.util.HashMap;
  26 import java.util.HashSet;
  27 import java.util.Map;
  28 import java.util.Optional;
  29 import java.util.Set;
  30
  31 public class RecipientHelper {
  32
  33     private final static Logger logger = LoggerFactory.getLogger(RecipientHelper.class);
  34
  35     private final SignalAccount account;
  36     private final SignalDependencies dependencies;
  37     private final ServiceEnvironmentConfig serviceEnvironmentConfig;
  38
  39     public RecipientHelper(final Context context) {
  40         this.account = context.getAccount();
  41         this.dependencies = context.getDependencies();
  42         this.serviceEnvironmentConfig = dependencies.getServiceEnvironmentConfig();
  43     }
  44
  45     public SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) {
  46         final var address = account.getRecipientAddressResolver().resolveRecipientAddress(recipientId);
  47         if (address.number().isEmpty() || address.serviceId().isPresent()) {
  48             return address.toSignalServiceAddress();
  49         }
  50
  51         // Address in recipient store doesn't have a uuid, this shouldn't happen
  52         // Try to retrieve the uuid from the server
  53         final var number = address.number().get();
  54         final ServiceId serviceId;
  55         try {
  56             serviceId = getRegisteredUser(number);
  57         } catch (UnregisteredRecipientException e) {
  58             logger.warn("Failed to get uuid for e164 number: {}", number);
  59             // Return SignalServiceAddress with unknown UUID
  60             return address.toSignalServiceAddress();
  61         } catch (IOException e) {
  62             logger.warn("Failed to get uuid for e164 number: {}", number, e);
  63             // Return SignalServiceAddress with unknown UUID
  64             return address.toSignalServiceAddress();
  65         }
  66         return account.getRecipientAddressResolver()
  67                 .resolveRecipientAddress(account.getRecipientResolver().resolveRecipient(serviceId))
  68                 .toSignalServiceAddress();
  69     }
  70
  71     public RecipientId resolveRecipient(final SignalServiceAddress address) {
  72         return account.getRecipientResolver().resolveRecipient(address);
  73     }
  74
  75     public Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws UnregisteredRecipientException {
  76         final var recipientIds = new HashSet<RecipientId>(recipients.size());
  77         for (var number : recipients) {
  78             final var recipientId = resolveRecipient(number);
  79             recipientIds.add(recipientId);
  80         }
  81         return recipientIds;
  82     }
  83
  84     public RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws UnregisteredRecipientException {
  85         if (recipient instanceof RecipientIdentifier.Uuid uuidRecipient) {
  86             return account.getRecipientResolver().resolveRecipient(ServiceId.from(uuidRecipient.uuid()));
  87         } else {
  88             final var number = ((RecipientIdentifier.Number) recipient).number();
  89             return account.getRecipientStore().resolveRecipient(number, () -> {
  90                 try {
  91                     return getRegisteredUser(number);
  92                 } catch (Exception e) {
  93                     return null;
  94                 }
  95             });
  96         }
  97     }
  98
  99     public RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException, UnregisteredRecipientException {
 100         final var address = resolveSignalServiceAddress(recipientId);
 101         if (address.getNumber().isEmpty()) {
 102             return recipientId;
 103         }
 104         final var number = address.getNumber().get();
 105         final var serviceId = getRegisteredUser(number);
 106         return account.getRecipientTrustedResolver()
 107                 .resolveRecipientTrusted(new SignalServiceAddress(serviceId, number));
 108     }
 109
 110     public Map<String, RegisteredUser> getRegisteredUsers(final Set<String> numbers) throws IOException {
 111         Map<String, RegisteredUser> registeredUsers;
 112         try {
 113             registeredUsers = getRegisteredUsersV2(numbers, true);
 114         } catch (IOException e) {
 115             logger.warn("CDSI request failed, trying fallback to CDS", e);
 116             registeredUsers = getRegisteredUsersV1(numbers);
 117         }
 118
 119         // Store numbers as recipients, so we have the number/uuid association
 120         registeredUsers.forEach((number, u) -> account.getRecipientTrustedResolver()
 121                 .resolveRecipientTrusted(u.aci, u.pni, Optional.of(number)));
 122
 123         return registeredUsers;
 124     }
 125
 126     private ServiceId getRegisteredUser(final String number) throws IOException, UnregisteredRecipientException {
 127         final Map<String, RegisteredUser> aciMap;
 128         try {
 129             aciMap = getRegisteredUsers(Set.of(number));
 130         } catch (NumberFormatException e) {
 131             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 132         }
 133         final var user = aciMap.get(number);
 134         if (user == null) {
 135             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 136         }
 137         return user.getServiceId();
 138     }
 139
 140     private Map<String, RegisteredUser> getRegisteredUsersV1(final Set<String> numbers) throws IOException {
 141         final Map<String, ACI> response;
 142         try {
 143             response = dependencies.getAccountManager()
 144                     .getRegisteredUsers(ServiceConfig.getIasKeyStore(),
 145                             numbers,
 146                             serviceEnvironmentConfig.getCdsMrenclave());
 147         } catch (Quote.InvalidQuoteFormatException | UnauthenticatedQuoteException | SignatureException |
 148                  UnauthenticatedResponseException | InvalidKeyException | NumberFormatException e) {
 149             throw new IOException(e);
 150         }
 151         final var registeredUsers = new HashMap<String, RegisteredUser>();
 152         response.forEach((key, value) -> registeredUsers.put(key,
 153                 new RegisteredUser(Optional.of(value), Optional.empty())));
 154         return registeredUsers;
 155     }
 156
 157     private Map<String, RegisteredUser> getRegisteredUsersV2(
 158             final Set<String> numbers, boolean useCompat
 159     ) throws IOException {
 160         // Only partial refresh is implemented here
 161         final CdsiV2Service.Response response;
 162         try {
 163             response = dependencies.getAccountManager()
 164                     .getRegisteredUsersWithCdsi(Set.of(),
 165                             numbers,
 166                             account.getRecipientStore().getServiceIdToProfileKeyMap(),
 167                             useCompat,
 168                             Optional.empty(),
 169                             serviceEnvironmentConfig.getCdsiMrenclave(),
 170                             token -> {
 171                                 // Not storing for partial refresh
 172                             });
 173         } catch (NumberFormatException e) {
 174             throw new IOException(e);
 175         }
 176         logger.debug("CDSI request successful, quota used by this request: {}", response.getQuotaUsedDebugOnly());
 177
 178         final var registeredUsers = new HashMap<String, RegisteredUser>();
 179         response.getResults()
 180                 .forEach((key, value) -> registeredUsers.put(key,
 181                         new RegisteredUser(value.getAci(), Optional.of(value.getPni()))));
 182         return registeredUsers;
 183     }
 184
 185     private ACI getRegisteredUserByUsername(String username) throws IOException {
 186         return dependencies.getAccountManager().getAciByUsername(username);
 187     }
 188
 189     public record RegisteredUser(Optional<ACI> aci, Optional<PNI> pni) {
 190
 191         public RegisteredUser {
 192             aci = aci.isPresent() && aci.get().equals(ServiceId.UNKNOWN) ? Optional.empty() : aci;
 193             pni = pni.isPresent() && pni.get().equals(ServiceId.UNKNOWN) ? Optional.empty() : pni;
 194             if (aci.isEmpty() && pni.isEmpty()) {
 195                 throw new AssertionError("Must have either a ACI or PNI!");
 196             }
 197         }
 198
 199         public ServiceId getServiceId() {
 200             return aci.map(a -> (ServiceId) a).or(this::pni).orElse(null);
 201         }
 202     }
 203 }