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.api.RecipientIdentifier;
   4 import org.asamk.signal.manager.api.UnregisteredRecipientException;
   5 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
   6 import org.asamk.signal.manager.internal.SignalDependencies;
   7 import org.asamk.signal.manager.storage.SignalAccount;
   8 import org.asamk.signal.manager.storage.recipients.RecipientId;
   9 import org.signal.libsignal.usernames.BaseUsernameException;
  10 import org.signal.libsignal.usernames.Username;
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13 import org.whispersystems.signalservice.api.push.ServiceId;
  14 import org.whispersystems.signalservice.api.push.ServiceId.ACI;
  15 import org.whispersystems.signalservice.api.push.ServiceId.PNI;
  16 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  17 import org.whispersystems.signalservice.api.services.CdsiV2Service;
  18 import org.whispersystems.util.Base64UrlSafe;
  19
  20 import java.io.IOException;
  21 import java.util.Collection;
  22 import java.util.HashMap;
  23 import java.util.HashSet;
  24 import java.util.Map;
  25 import java.util.Optional;
  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.getRecipientAddressResolver().resolveRecipientAddress(recipientId);
  44         if (address.number().isEmpty() || address.serviceId().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 ServiceId serviceId;
  52         try {
  53             serviceId = getRegisteredUserByNumber(number);
  54         } catch (UnregisteredRecipientException e) {
  55             logger.warn("Failed to get uuid for e164 number: {}", number);
  56             // Return SignalServiceAddress with unknown UUID
  57             return address.toSignalServiceAddress();
  58         } catch (IOException e) {
  59             logger.warn("Failed to get uuid for e164 number: {}", number, e);
  60             // Return SignalServiceAddress with unknown UUID
  61             return address.toSignalServiceAddress();
  62         }
  63         return account.getRecipientAddressResolver()
  64                 .resolveRecipientAddress(account.getRecipientResolver().resolveRecipient(serviceId))
  65                 .toSignalServiceAddress();
  66     }
  67
  68     public RecipientId resolveRecipient(final SignalServiceAddress address) {
  69         return account.getRecipientResolver().resolveRecipient(address);
  70     }
  71
  72     public Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws UnregisteredRecipientException {
  73         final var recipientIds = new HashSet<RecipientId>(recipients.size());
  74         for (var number : recipients) {
  75             final var recipientId = resolveRecipient(number);
  76             recipientIds.add(recipientId);
  77         }
  78         return recipientIds;
  79     }
  80
  81     public RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws UnregisteredRecipientException {
  82         if (recipient instanceof RecipientIdentifier.Uuid uuidRecipient) {
  83             return account.getRecipientResolver().resolveRecipient(ACI.from(uuidRecipient.uuid()));
  84         } else if (recipient instanceof RecipientIdentifier.Number numberRecipient) {
  85             final var number = numberRecipient.number();
  86             return account.getRecipientStore().resolveRecipientByNumber(number, () -> {
  87                 try {
  88                     return getRegisteredUserByNumber(number);
  89                 } catch (Exception e) {
  90                     return null;
  91                 }
  92             });
  93         } else if (recipient instanceof RecipientIdentifier.Username usernameRecipient) {
  94             final var username = usernameRecipient.username();
  95             return account.getRecipientStore().resolveRecipientByUsername(username, () -> {
  96                 try {
  97                     return getRegisteredUserByUsername(username);
  98                 } catch (Exception e) {
  99                     return null;
 100                 }
 101             });
 102         }
 103         throw new AssertionError("Unexpected RecipientIdentifier: " + recipient);
 104     }
 105
 106     public Optional<RecipientId> resolveRecipientOptional(final RecipientIdentifier.Single recipient) {
 107         try {
 108             return Optional.of(resolveRecipient(recipient));
 109         } catch (UnregisteredRecipientException e) {
 110             if (recipient instanceof RecipientIdentifier.Number r) {
 111                 return account.getRecipientStore().resolveRecipientByNumberOptional(r.number());
 112             } else {
 113                 return Optional.empty();
 114             }
 115         }
 116     }
 117
 118     public RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException, UnregisteredRecipientException {
 119         final var address = resolveSignalServiceAddress(recipientId);
 120         if (address.getNumber().isEmpty()) {
 121             return recipientId;
 122         }
 123         final var number = address.getNumber().get();
 124         final var serviceId = getRegisteredUserByNumber(number);
 125         return account.getRecipientTrustedResolver()
 126                 .resolveRecipientTrusted(new SignalServiceAddress(serviceId, number));
 127     }
 128
 129     public Map<String, RegisteredUser> getRegisteredUsers(final Set<String> numbers) throws IOException {
 130         Map<String, RegisteredUser> registeredUsers = getRegisteredUsersV2(numbers, true);
 131
 132         // Store numbers as recipients, so we have the number/uuid association
 133         registeredUsers.forEach((number, u) -> account.getRecipientTrustedResolver()
 134                 .resolveRecipientTrusted(u.aci, u.pni, Optional.of(number)));
 135
 136         return registeredUsers;
 137     }
 138
 139     private ServiceId getRegisteredUserByNumber(final String number) throws IOException, UnregisteredRecipientException {
 140         final Map<String, RegisteredUser> aciMap;
 141         try {
 142             aciMap = getRegisteredUsers(Set.of(number));
 143         } catch (NumberFormatException e) {
 144             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 145         }
 146         final var user = aciMap.get(number);
 147         if (user == null) {
 148             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 149         }
 150         return user.getServiceId();
 151     }
 152
 153     private Map<String, RegisteredUser> getRegisteredUsersV2(
 154             final Set<String> numbers, boolean useCompat
 155     ) throws IOException {
 156         // Only partial refresh is implemented here
 157         final CdsiV2Service.Response response;
 158         try {
 159             response = dependencies.getAccountManager()
 160                     .getRegisteredUsersWithCdsi(Set.of(),
 161                             numbers,
 162                             account.getRecipientStore().getServiceIdToProfileKeyMap(),
 163                             useCompat,
 164                             Optional.empty(),
 165                             serviceEnvironmentConfig.getCdsiMrenclave(),
 166                             null,
 167                             token -> {
 168                                 // Not storing for partial refresh
 169                             });
 170         } catch (NumberFormatException e) {
 171             throw new IOException(e);
 172         }
 173         logger.debug("CDSI request successful, quota used by this request: {}", response.getQuotaUsedDebugOnly());
 174
 175         final var registeredUsers = new HashMap<String, RegisteredUser>();
 176         response.getResults()
 177                 .forEach((key, value) -> registeredUsers.put(key,
 178                         new RegisteredUser(value.getAci(), Optional.of(value.getPni()))));
 179         return registeredUsers;
 180     }
 181
 182     private ACI getRegisteredUserByUsername(String username) throws IOException, BaseUsernameException {
 183         return dependencies.getAccountManager()
 184                 .getAciByUsernameHash(Base64UrlSafe.encodeBytesWithoutPadding(new Username(username).getHash()));
 185     }
 186
 187     public record RegisteredUser(Optional<ACI> aci, Optional<PNI> pni) {
 188
 189         public RegisteredUser {
 190             aci = aci.isPresent() && aci.get().isUnknown() ? Optional.empty() : aci;
 191             pni = pni.isPresent() && pni.get().isUnknown() ? Optional.empty() : pni;
 192             if (aci.isEmpty() && pni.isEmpty()) {
 193                 throw new AssertionError("Must have either a ACI or PNI!");
 194             }
 195         }
 196
 197         public ServiceId getServiceId() {
 198             return aci.map(a -> (ServiceId) a).or(this::pni).orElse(null);
 199         }
 200     }
 201 }