import org.asamk.signal.manager.api.RecipientIdentifier;
import org.asamk.signal.manager.api.UnregisteredRecipientException;
-import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
+import org.asamk.signal.manager.api.UsernameLinkUrl;
import org.asamk.signal.manager.internal.SignalDependencies;
import org.asamk.signal.manager.storage.SignalAccount;
import org.asamk.signal.manager.storage.recipients.RecipientId;
import org.signal.libsignal.usernames.Username;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.whispersystems.signalservice.api.cds.CdsiV2Service;
import org.whispersystems.signalservice.api.push.ServiceId;
import org.whispersystems.signalservice.api.push.ServiceId.ACI;
import org.whispersystems.signalservice.api.push.ServiceId.PNI;
import org.whispersystems.signalservice.api.push.SignalServiceAddress;
+import org.whispersystems.signalservice.api.push.exceptions.CdsiInvalidArgumentException;
import org.whispersystems.signalservice.api.push.exceptions.CdsiInvalidTokenException;
-import org.whispersystems.signalservice.api.services.CdsiV2Service;
-import org.whispersystems.util.Base64UrlSafe;
+import org.whispersystems.signalservice.api.push.exceptions.NonSuccessfulResponseCodeException;
import java.io.IOException;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.UUID;
+
+import static org.asamk.signal.manager.config.ServiceConfig.MAXIMUM_ONE_OFF_REQUEST_SIZE;
+import static org.asamk.signal.manager.util.Utils.handleResponseException;
public class RecipientHelper {
- private final static Logger logger = LoggerFactory.getLogger(RecipientHelper.class);
+ private static final Logger logger = LoggerFactory.getLogger(RecipientHelper.class);
private final SignalAccount account;
private final SignalDependencies dependencies;
- private final ServiceEnvironmentConfig serviceEnvironmentConfig;
public RecipientHelper(final Context context) {
this.account = context.getAccount();
this.dependencies = context.getDependencies();
- this.serviceEnvironmentConfig = dependencies.getServiceEnvironmentConfig();
}
public SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) {
.toSignalServiceAddress();
}
- public RecipientId resolveRecipient(final SignalServiceAddress address) {
- return account.getRecipientResolver().resolveRecipient(address);
- }
-
- public Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws UnregisteredRecipientException {
+ public Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws UnregisteredRecipientException, IOException {
final var recipientIds = new HashSet<RecipientId>(recipients.size());
for (var number : recipients) {
final var recipientId = resolveRecipient(number);
}
public RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws UnregisteredRecipientException {
- if (recipient instanceof RecipientIdentifier.Uuid uuidRecipient) {
- return account.getRecipientResolver().resolveRecipient(ACI.from(uuidRecipient.uuid()));
- } else if (recipient instanceof RecipientIdentifier.Number numberRecipient) {
- final var number = numberRecipient.number();
+ if (recipient instanceof RecipientIdentifier.Uuid(UUID uuid)) {
+ return account.getRecipientResolver().resolveRecipient(ACI.from(uuid));
+ } else if (recipient instanceof RecipientIdentifier.Pni(UUID pni)) {
+ return account.getRecipientResolver().resolveRecipient(PNI.from(pni));
+ } else if (recipient instanceof RecipientIdentifier.Number(String number)) {
return account.getRecipientStore().resolveRecipientByNumber(number, () -> {
try {
return getRegisteredUserByNumber(number);
return null;
}
});
- } else if (recipient instanceof RecipientIdentifier.Username usernameRecipient) {
- final var username = usernameRecipient.username();
- return account.getRecipientStore().resolveRecipientByUsername(username, () -> {
- try {
- return getRegisteredUserByUsername(username);
- } catch (Exception e) {
- return null;
- }
- });
+ } else if (recipient instanceof RecipientIdentifier.Username(String username)) {
+ try {
+ return resolveRecipientByUsernameOrLink(username, false);
+ } catch (Exception e) {
+ return null;
+ }
}
throw new AssertionError("Unexpected RecipientIdentifier: " + recipient);
}
+ public RecipientId resolveRecipientByUsernameOrLink(
+ String username,
+ boolean forceRefresh
+ ) throws UnregisteredRecipientException, IOException {
+ final Username finalUsername;
+ try {
+ finalUsername = getUsernameFromUsernameOrLink(username);
+ } catch (IOException | BaseUsernameException e) {
+ throw new RuntimeException(e);
+ }
+ if (forceRefresh) {
+ try {
+ final var aci = handleResponseException(dependencies.getUsernameApi().getAciByUsername(finalUsername));
+ return account.getRecipientStore().resolveRecipientTrusted(aci, finalUsername.getUsername());
+ } catch (NonSuccessfulResponseCodeException e) {
+ if (e.code == 404) {
+ throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null,
+ null,
+ null,
+ username));
+ }
+ logger.debug("Failed to get uuid for username: {}", username, e);
+ throw e;
+ }
+ }
+ return account.getRecipientStore().resolveRecipientByUsername(finalUsername.getUsername(), () -> {
+ try {
+ return handleResponseException(dependencies.getUsernameApi().getAciByUsername(finalUsername));
+ } catch (Exception e) {
+ return null;
+ }
+ });
+ }
+
+ private Username getUsernameFromUsernameOrLink(String username) throws BaseUsernameException, IOException {
+ try {
+ final var usernameLinkUrl = UsernameLinkUrl.fromUri(username);
+ final var components = usernameLinkUrl.getComponents();
+ final var encryptedUsername = handleResponseException(dependencies.getUsernameApi()
+ .getEncryptedUsernameFromLinkServerId(components.getServerId()));
+ final var link = new Username.UsernameLink(components.getEntropy(), encryptedUsername);
+
+ return Username.fromLink(link);
+ } catch (UsernameLinkUrl.InvalidUsernameLinkException e) {
+ return new Username(username);
+ }
+ }
+
public Optional<RecipientId> resolveRecipientOptional(final RecipientIdentifier.Single recipient) {
try {
return Optional.of(resolveRecipient(recipient));
} catch (UnregisteredRecipientException e) {
- if (recipient instanceof RecipientIdentifier.Number r) {
- return account.getRecipientStore().resolveRecipientByNumberOptional(r.number());
+ if (recipient instanceof RecipientIdentifier.Number(String number)) {
+ return account.getRecipientStore().resolveRecipientByNumberOptional(number);
} else {
return Optional.empty();
}
public Map<String, RegisteredUser> getRegisteredUsers(
final Set<String> numbers
) throws IOException {
- return getRegisteredUsers(numbers, true);
+ if (numbers.size() > MAXIMUM_ONE_OFF_REQUEST_SIZE) {
+ final var allNumbers = new HashSet<>(account.getRecipientStore().getAllNumbers()) {{
+ addAll(numbers);
+ }};
+ return getRegisteredUsers(allNumbers, false);
+ } else {
+ return getRegisteredUsers(numbers, true);
+ }
}
private Map<String, RegisteredUser> getRegisteredUsers(
- final Set<String> numbers, final boolean isPartialRefresh
+ final Set<String> numbers,
+ final boolean isPartialRefresh
) throws IOException {
- Map<String, RegisteredUser> registeredUsers = getRegisteredUsersV2(numbers, isPartialRefresh, true);
+ Map<String, RegisteredUser> registeredUsers = getRegisteredUsersV2(numbers, isPartialRefresh);
// Store numbers as recipients, so we have the number/uuid association
registeredUsers.forEach((number, u) -> account.getRecipientTrustedResolver()
.resolveRecipientTrusted(u.aci, u.pni, Optional.of(number)));
+ final var unregisteredUsers = new HashSet<>(numbers);
+ unregisteredUsers.removeAll(registeredUsers.keySet());
+ account.getRecipientStore().markUndiscoverablePossiblyUnregistered(unregisteredUsers);
+ account.getRecipientStore().markDiscoverable(registeredUsers.keySet());
+
return registeredUsers;
}
try {
aciMap = getRegisteredUsers(Set.of(number), true);
} catch (NumberFormatException e) {
- throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
+ throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(number));
}
final var user = aciMap.get(number);
if (user == null) {
- throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(null, number));
+ throw new UnregisteredRecipientException(new org.asamk.signal.manager.api.RecipientAddress(number));
}
return user.getServiceId();
}
private Map<String, RegisteredUser> getRegisteredUsersV2(
- final Set<String> numbers, boolean isPartialRefresh, boolean useCompat
+ final Set<String> numbers,
+ boolean isPartialRefresh
) throws IOException {
final var previousNumbers = isPartialRefresh ? Set.<String>of() : account.getCdsiStore().getAllNumbers();
final var newNumbers = new HashSet<>(numbers) {{
logger.debug("No new numbers to query.");
return Map.of();
}
- logger.trace("Querying CDSI for {} new numbers ({} previous)", newNumbers.size(), previousNumbers.size());
+ logger.trace("Querying CDSI for {} new numbers ({} previous), isPartialRefresh={}",
+ newNumbers.size(),
+ previousNumbers.size(),
+ isPartialRefresh);
final var token = previousNumbers.isEmpty()
? Optional.<byte[]>empty()
: Optional.ofNullable(account.getCdsiToken());
final CdsiV2Service.Response response;
try {
- response = dependencies.getAccountManager()
- .getRegisteredUsersWithCdsi(previousNumbers,
+ response = handleResponseException(dependencies.getCdsApi()
+ .getRegisteredUsers(token.isEmpty() ? Set.of() : previousNumbers,
newNumbers,
account.getRecipientStore().getServiceIdToProfileKeyMap(),
- useCompat,
token,
- serviceEnvironmentConfig.cdsiMrenclave(),
null,
+ dependencies.getLibSignalNetwork(),
newToken -> {
if (isPartialRefresh) {
account.getCdsiStore().updateAfterPartialCdsQuery(newNumbers);
}};
account.getCdsiStore().updateAfterFullCdsQuery(fullNumbers, seenNumbers);
account.setCdsiToken(newToken);
+ account.setLastRecipientsRefresh(System.currentTimeMillis());
}
- });
- } catch (CdsiInvalidTokenException e) {
+ }));
+ } catch (CdsiInvalidTokenException | CdsiInvalidArgumentException e) {
account.setCdsiToken(null);
account.getCdsiStore().clearAll();
throw e;
return registeredUsers;
}
- private ACI getRegisteredUserByUsername(String username) throws IOException, BaseUsernameException {
- return dependencies.getAccountManager()
- .getAciByUsernameHash(Base64UrlSafe.encodeBytesWithoutPadding(new Username(username).getHash()));
- }
-
public record RegisteredUser(Optional<ACI> aci, Optional<PNI> pni) {
public RegisteredUser {
git.nmode.ca / signal-cli / blobdiff
