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.api.UsernameLinkUrl;
   6 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
   7 import org.asamk.signal.manager.internal.SignalDependencies;
   8 import org.asamk.signal.manager.storage.SignalAccount;
   9 import org.asamk.signal.manager.storage.recipients.RecipientId;
  10 import org.signal.libsignal.usernames.BaseUsernameException;
  11 import org.signal.libsignal.usernames.Username;
  12 import org.slf4j.Logger;
  13 import org.slf4j.LoggerFactory;
  14 import org.whispersystems.signalservice.api.push.ServiceId;
  15 import org.whispersystems.signalservice.api.push.ServiceId.ACI;
  16 import org.whispersystems.signalservice.api.push.ServiceId.PNI;
  17 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  18 import org.whispersystems.signalservice.api.push.exceptions.CdsiInvalidTokenException;
  19 import org.whispersystems.signalservice.api.services.CdsiV2Service;
  20
  21 import java.io.IOException;
  22 import java.util.Collection;
  23 import java.util.HashMap;
  24 import java.util.HashSet;
  25 import java.util.Map;
  26 import java.util.Optional;
  27 import java.util.Set;
  28
  29 import static org.asamk.signal.manager.config.ServiceConfig.MAXIMUM_ONE_OFF_REQUEST_SIZE;
  30
  31 public class RecipientHelper {
  32
  33     private static final 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 = getRegisteredUserByNumber(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(ACI.from(uuidRecipient.uuid()));
  87         } else if (recipient instanceof RecipientIdentifier.Number numberRecipient) {
  88             final var number = numberRecipient.number();
  89             return account.getRecipientStore().resolveRecipientByNumber(number, () -> {
  90                 try {
  91                     return getRegisteredUserByNumber(number);
  92                 } catch (Exception e) {
  93                     return null;
  94                 }
  95             });
  96         } else if (recipient instanceof RecipientIdentifier.Username usernameRecipient) {
  97             var username = usernameRecipient.username();
  98             try {
  99                 UsernameLinkUrl usernameLinkUrl = UsernameLinkUrl.fromUri(username);
 100                 final var components = usernameLinkUrl.getComponents();
 101                 final var encryptedUsername = dependencies.getAccountManager()
 102                         .getEncryptedUsernameFromLinkServerId(components.getServerId());
 103                 final var link = new Username.UsernameLink(components.getEntropy(), encryptedUsername);
 104
 105                 username = Username.fromLink(link).getUsername();
 106             } catch (UsernameLinkUrl.InvalidUsernameLinkException e) {
 107             } catch (IOException | BaseUsernameException e) {
 108                 throw new RuntimeException(e);
 109             }
 110             final String finalUsername = username;
 111             return account.getRecipientStore().resolveRecipientByUsername(finalUsername, () -> {
 112                 try {
 113                     return getRegisteredUserByUsername(finalUsername);
 114                 } catch (Exception e) {
 115                     return null;
 116                 }
 117             });
 118         }
 119         throw new AssertionError("Unexpected RecipientIdentifier: " + recipient);
 120     }
 121
 122     public Optional<RecipientId> resolveRecipientOptional(final RecipientIdentifier.Single recipient) {
 123         try {
 124             return Optional.of(resolveRecipient(recipient));
 125         } catch (UnregisteredRecipientException e) {
 126             if (recipient instanceof RecipientIdentifier.Number r) {
 127                 return account.getRecipientStore().resolveRecipientByNumberOptional(r.number());
 128             } else {
 129                 return Optional.empty();
 130             }
 131         }
 132     }
 133
 134     public void refreshUsers() throws IOException {
 135         getRegisteredUsers(account.getRecipientStore().getAllNumbers(), false);
 136     }
 137
 138     public RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException, UnregisteredRecipientException {
 139         final var address = resolveSignalServiceAddress(recipientId);
 140         if (address.getNumber().isEmpty()) {
 141             return recipientId;
 142         }
 143         final var number = address.getNumber().get();
 144         final var serviceId = getRegisteredUserByNumber(number);
 145         return account.getRecipientTrustedResolver()
 146                 .resolveRecipientTrusted(new SignalServiceAddress(serviceId, number));
 147     }
 148
 149     public Map<String, RegisteredUser> getRegisteredUsers(
 150             final Set<String> numbers
 151     ) throws IOException {
 152         if (numbers.size() > MAXIMUM_ONE_OFF_REQUEST_SIZE) {
 153             final var allNumbers = new HashSet<>(account.getRecipientStore().getAllNumbers()) {{
 154                 addAll(numbers);
 155             }};
 156             return getRegisteredUsers(allNumbers, false);
 157         } else {
 158             return getRegisteredUsers(numbers, true);
 159         }
 160     }
 161
 162     private Map<String, RegisteredUser> getRegisteredUsers(
 163             final Set<String> numbers, final boolean isPartialRefresh
 164     ) throws IOException {
 165         Map<String, RegisteredUser> registeredUsers = getRegisteredUsersV2(numbers, isPartialRefresh, true);
 166
 167         // Store numbers as recipients, so we have the number/uuid association
 168         registeredUsers.forEach((number, u) -> account.getRecipientTrustedResolver()
 169                 .resolveRecipientTrusted(u.aci, u.pni, Optional.of(number)));
 170
 171         return registeredUsers;
 172     }
 173
 174     private ServiceId getRegisteredUserByNumber(final String number) throws IOException, UnregisteredRecipientException {
 175         final Map<String, RegisteredUser> aciMap;
 176         try {
 177             aciMap = getRegisteredUsers(Set.of(number), true);
 178         } catch (NumberFormatException e) {
 179             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 180         }
 181         final var user = aciMap.get(number);
 182         if (user == null) {
 183             throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
 184         }
 185         return user.getServiceId();
 186     }
 187
 188     private Map<String, RegisteredUser> getRegisteredUsersV2(
 189             final Set<String> numbers, boolean isPartialRefresh, boolean useCompat
 190     ) throws IOException {
 191         final var previousNumbers = isPartialRefresh ? Set.<String>of() : account.getCdsiStore().getAllNumbers();
 192         final var newNumbers = new HashSet<>(numbers) {{
 193             removeAll(previousNumbers);
 194         }};
 195         if (newNumbers.isEmpty() && previousNumbers.isEmpty()) {
 196             logger.debug("No new numbers to query.");
 197             return Map.of();
 198         }
 199         logger.trace("Querying CDSI for {} new numbers ({} previous), isPartialRefresh={}",
 200                 newNumbers.size(),
 201                 previousNumbers.size(),
 202                 isPartialRefresh);
 203         final var token = previousNumbers.isEmpty()
 204                 ? Optional.<byte[]>empty()
 205                 : Optional.ofNullable(account.getCdsiToken());
 206
 207         final CdsiV2Service.Response response;
 208         try {
 209             response = dependencies.getAccountManager()
 210                     .getRegisteredUsersWithCdsi(previousNumbers,
 211                             newNumbers,
 212                             account.getRecipientStore().getServiceIdToProfileKeyMap(),
 213                             useCompat,
 214                             token,
 215                             serviceEnvironmentConfig.cdsiMrenclave(),
 216                             null,
 217                             newToken -> {
 218                                 if (isPartialRefresh) {
 219                                     account.getCdsiStore().updateAfterPartialCdsQuery(newNumbers);
 220                                     // Not storing newToken for partial refresh
 221                                 } else {
 222                                     final var fullNumbers = new HashSet<>(previousNumbers) {{
 223                                         addAll(newNumbers);
 224                                     }};
 225                                     final var seenNumbers = new HashSet<>(numbers) {{
 226                                         addAll(newNumbers);
 227                                     }};
 228                                     account.getCdsiStore().updateAfterFullCdsQuery(fullNumbers, seenNumbers);
 229                                     account.setCdsiToken(newToken);
 230                                     account.setLastRecipientsRefresh(System.currentTimeMillis());
 231                                 }
 232                             });
 233         } catch (CdsiInvalidTokenException e) {
 234             account.setCdsiToken(null);
 235             account.getCdsiStore().clearAll();
 236             throw e;
 237         } catch (NumberFormatException e) {
 238             throw new IOException(e);
 239         }
 240         logger.debug("CDSI request successful, quota used by this request: {}", response.getQuotaUsedDebugOnly());
 241
 242         final var registeredUsers = new HashMap<String, RegisteredUser>();
 243         response.getResults()
 244                 .forEach((key, value) -> registeredUsers.put(key,
 245                         new RegisteredUser(value.getAci(), Optional.of(value.getPni()))));
 246         return registeredUsers;
 247     }
 248
 249     private ACI getRegisteredUserByUsername(String username) throws IOException, BaseUsernameException {
 250         return dependencies.getAccountManager().getAciByUsername(new Username(username));
 251     }
 252
 253     public record RegisteredUser(Optional<ACI> aci, Optional<PNI> pni) {
 254
 255         public RegisteredUser {
 256             aci = aci.isPresent() && aci.get().isUnknown() ? Optional.empty() : aci;
 257             pni = pni.isPresent() && pni.get().isUnknown() ? Optional.empty() : pni;
 258             if (aci.isEmpty() && pni.isEmpty()) {
 259                 throw new AssertionError("Must have either a ACI or PNI!");
 260             }
 261         }
 262
 263         public ServiceId getServiceId() {
 264             return aci.map(a -> (ServiceId) a).or(this::pni).orElse(null);
 265         }
 266     }
 267 }