X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/e2b7bda65ba728a0a747bb0bac6fbe1e56fd2de8..a54fc92c05c5c8b532e029e82eedd73f9440e138:/src/main/java/org/asamk/signal/manager/Manager.java diff --git a/src/main/java/org/asamk/signal/manager/Manager.java b/src/main/java/org/asamk/signal/manager/Manager.java index a8be8ad8..c332a959 100644 --- a/src/main/java/org/asamk/signal/manager/Manager.java +++ b/src/main/java/org/asamk/signal/manager/Manager.java @@ -18,20 +18,13 @@ package org.asamk.signal.manager; import com.fasterxml.jackson.databind.ObjectMapper; -import org.asamk.Signal; -import org.asamk.signal.AttachmentInvalidException; -import org.asamk.signal.GroupNotFoundException; -import org.asamk.signal.JsonStickerPack; -import org.asamk.signal.NotAGroupMemberException; -import org.asamk.signal.StickerPackInvalidException; -import org.asamk.signal.TrustLevel; -import org.asamk.signal.UserAlreadyExists; import org.asamk.signal.storage.SignalAccount; import org.asamk.signal.storage.contacts.ContactInfo; import org.asamk.signal.storage.groups.GroupInfo; import org.asamk.signal.storage.groups.JsonGroupStore; +import org.asamk.signal.storage.profiles.SignalProfile; +import org.asamk.signal.storage.profiles.SignalProfileEntry; import org.asamk.signal.storage.protocol.JsonIdentityKeyStore; -import org.asamk.signal.storage.threads.ThreadInfo; import org.asamk.signal.util.IOUtils; import org.asamk.signal.util.Util; import org.signal.libsignal.metadata.InvalidMetadataMessageException; @@ -47,7 +40,7 @@ import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException; import org.signal.libsignal.metadata.SelfSendException; import org.signal.libsignal.metadata.certificate.InvalidCertificateException; import org.signal.zkgroup.InvalidInputException; -import org.signal.zkgroup.VerificationFailedException; +import org.signal.zkgroup.profiles.ClientZkProfileOperations; import org.signal.zkgroup.profiles.ProfileKey; import org.whispersystems.libsignal.IdentityKey; import org.whispersystems.libsignal.IdentityKeyPair; @@ -73,14 +66,18 @@ import org.whispersystems.signalservice.api.crypto.SignalServiceCipher; import org.whispersystems.signalservice.api.crypto.UnidentifiedAccess; import org.whispersystems.signalservice.api.crypto.UnidentifiedAccessPair; import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException; +import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations; +import org.whispersystems.signalservice.api.groupsv2.GroupsV2Operations; import org.whispersystems.signalservice.api.messages.SendMessageResult; import org.whispersystems.signalservice.api.messages.SignalServiceAttachment; import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer; +import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId; import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentStream; import org.whispersystems.signalservice.api.messages.SignalServiceContent; import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage; import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope; import org.whispersystems.signalservice.api.messages.SignalServiceGroup; +import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage; import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload; import org.whispersystems.signalservice.api.messages.SignalServiceStickerManifestUpload.StickerInfo; import org.whispersystems.signalservice.api.messages.multidevice.BlockedListMessage; @@ -99,19 +96,24 @@ import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage import org.whispersystems.signalservice.api.profiles.SignalServiceProfile; import org.whispersystems.signalservice.api.push.ContactTokenDetails; import org.whispersystems.signalservice.api.push.SignalServiceAddress; -import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException; import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions; +import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException; import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException; import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException; import org.whispersystems.signalservice.api.util.InvalidNumberException; import org.whispersystems.signalservice.api.util.SleepTimer; import org.whispersystems.signalservice.api.util.StreamDetails; import org.whispersystems.signalservice.api.util.UptimeSleepTimer; +import org.whispersystems.signalservice.api.util.UuidUtil; +import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration; import org.whispersystems.signalservice.internal.push.SignalServiceProtos; import org.whispersystems.signalservice.internal.push.UnsupportedDataMessageException; +import org.whispersystems.signalservice.internal.push.VerifyAccountResponse; +import org.whispersystems.signalservice.internal.util.DynamicCredentialsProvider; import org.whispersystems.signalservice.internal.util.Hex; import org.whispersystems.util.Base64; +import java.io.Closeable; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; @@ -134,49 +136,66 @@ import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Locale; -import java.util.Map; import java.util.Objects; import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; +import java.util.stream.Collectors; import java.util.zip.ZipEntry; import java.util.zip.ZipFile; -public class Manager implements Signal { +import static org.asamk.signal.manager.ServiceConfig.capabilities; - private static final SignalServiceProfile.Capabilities capabilities = new SignalServiceProfile.Capabilities(false, false); +public class Manager implements Closeable { - private final String settingsPath; - private final String dataPath; - private final String attachmentsPath; - private final String avatarsPath; private final SleepTimer timer = new UptimeSleepTimer(); + private final SignalServiceConfiguration serviceConfiguration; + private final String userAgent; - private SignalAccount account; - private String username; + private final SignalAccount account; + private final PathConfig pathConfig; private SignalServiceAccountManager accountManager; private SignalServiceMessagePipe messagePipe = null; private SignalServiceMessagePipe unidentifiedMessagePipe = null; + private boolean discoverableByPhoneNumber = true; - public Manager(String username, String settingsPath) { - this.username = username; - this.settingsPath = settingsPath; - this.dataPath = this.settingsPath + "/data"; - this.attachmentsPath = this.settingsPath + "/attachments"; - this.avatarsPath = this.settingsPath + "/avatars"; + public Manager(SignalAccount account, PathConfig pathConfig, SignalServiceConfiguration serviceConfiguration, String userAgent) { + this.account = account; + this.pathConfig = pathConfig; + this.serviceConfiguration = serviceConfiguration; + this.userAgent = userAgent; + this.accountManager = createSignalServiceAccountManager(); + this.account.setResolver(this::resolveSignalServiceAddress); } public String getUsername() { - return username; + return account.getUsername(); } - private SignalServiceAccountManager getSignalServiceAccountManager() { - return new SignalServiceAccountManager(BaseConfig.serviceConfiguration, null, account.getUsername(), account.getPassword(), account.getDeviceId(), BaseConfig.USER_AGENT, timer); + public SignalServiceAddress getSelfAddress() { + return account.getSelfAddress(); } - private IdentityKey getIdentity() { - return account.getSignalProtocolStore().getIdentityKeyPair().getPublicKey(); + private SignalServiceAccountManager createSignalServiceAccountManager() { + GroupsV2Operations groupsV2Operations; + try { + groupsV2Operations = new GroupsV2Operations(ClientZkOperations.create(serviceConfiguration)); + } catch (Throwable ignored) { + groupsV2Operations = null; + } + return new SignalServiceAccountManager(serviceConfiguration, + new DynamicCredentialsProvider(account.getUuid(), account.getUsername(), account.getPassword(), null, account.getDeviceId()), + userAgent, + groupsV2Operations, + timer); + } + + private IdentityKeyPair getIdentityKeyPair() { + return account.getSignalProtocolStore().getIdentityKeyPair(); } public int getDeviceId() { @@ -184,10 +203,14 @@ public class Manager implements Signal { } private String getMessageCachePath() { - return this.dataPath + "/" + username + ".d/msg-cache"; + return pathConfig.getDataPath() + "/" + account.getUsername() + ".d/msg-cache"; } private String getMessageCachePath(String sender) { + if (sender == null || sender.isEmpty()) { + return getMessageCachePath(); + } + return getMessageCachePath() + "/" + sender.replace("/", "_"); } @@ -197,28 +220,27 @@ public class Manager implements Signal { return new File(cachePath + "/" + now + "_" + timestamp); } - public boolean userHasKeys() { - return account != null && account.getSignalProtocolStore() != null; - } + public static Manager init(String username, String settingsPath, SignalServiceConfiguration serviceConfiguration, String userAgent) throws IOException { + PathConfig pathConfig = PathConfig.createDefault(settingsPath); - public void init() throws IOException { - if (!SignalAccount.userExists(dataPath, username)) { - return; - } - account = SignalAccount.load(dataPath, username); + if (!SignalAccount.userExists(pathConfig.getDataPath(), username)) { + IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair(); + int registrationId = KeyHelper.generateRegistrationId(false); - migrateLegacyConfigs(); + ProfileKey profileKey = KeyUtils.createProfileKey(); + SignalAccount account = SignalAccount.create(pathConfig.getDataPath(), username, identityKey, registrationId, profileKey); + account.save(); - accountManager = getSignalServiceAccountManager(); - try { - if (account.isRegistered() && accountManager.getPreKeysCount() < BaseConfig.PREKEY_MINIMUM_COUNT) { - refreshPreKeys(); - account.save(); - } - } catch (AuthorizationFailedException e) { - System.err.println("Authorization failed, was the number registered elsewhere?"); - throw e; + return new Manager(account, pathConfig, serviceConfiguration, userAgent); } + + SignalAccount account = SignalAccount.load(pathConfig.getDataPath(), username); + + Manager m = new Manager(account, pathConfig, serviceConfiguration, userAgent); + + m.migrateLegacyConfigs(); + + return m; } private void migrateLegacyConfigs() { @@ -227,10 +249,10 @@ public class Manager implements Signal { if (JsonGroupStore.groupsWithLegacyAvatarId.size() > 0) { for (GroupInfo g : JsonGroupStore.groupsWithLegacyAvatarId) { File avatarFile = getGroupAvatarFile(g.groupId); - File attachmentFile = getAttachmentFile(g.getAvatarId()); + File attachmentFile = getAttachmentFile(new SignalServiceAttachmentRemoteId(g.getAvatarId())); if (!avatarFile.exists() && attachmentFile.exists()) { try { - IOUtils.createPrivateDirectories(avatarsPath); + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); Files.copy(attachmentFile.toPath(), avatarFile.toPath(), StandardCopyOption.REPLACE_EXISTING); } catch (Exception e) { // Ignore @@ -247,28 +269,29 @@ public class Manager implements Signal { } } - private void createNewIdentity() throws IOException { - IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair(); - int registrationId = KeyHelper.generateRegistrationId(false); - if (username == null) { - account = SignalAccount.createTemporaryAccount(identityKey, registrationId); - } else { - ProfileKey profileKey = KeyUtils.createProfileKey(); - account = SignalAccount.create(dataPath, username, identityKey, registrationId, profileKey); - account.save(); + public void checkAccountState() throws IOException { + if (account.isRegistered()) { + if (accountManager.getPreKeysCount() < ServiceConfig.PREKEY_MINIMUM_COUNT) { + refreshPreKeys(); + account.save(); + } + if (account.getUuid() == null) { + account.setUuid(accountManager.getOwnUuid()); + account.save(); + } } } public boolean isRegistered() { - return account != null && account.isRegistered(); + return account.isRegistered(); } public void register(boolean voiceVerification) throws IOException { - if (account == null) { - createNewIdentity(); - } account.setPassword(KeyUtils.createPassword()); - accountManager = getSignalServiceAccountManager(); + + // Resetting UUID, because registering doesn't work otherwise + account.setUuid(null); + accountManager = createSignalServiceAccountManager(); if (voiceVerification) { accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.absent(), Optional.absent()); @@ -281,21 +304,13 @@ public class Manager implements Signal { } public void updateAccountAttributes() throws IOException { - accountManager.setAccountAttributes(account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, account.getRegistrationLockPin(), account.getRegistrationLock(), getSelfUnidentifiedAccessKey(), false, capabilities); - } - - public void setProfileName(String name) throws IOException { - accountManager.setProfileName(account.getProfileKey(), name); - } - - public void setProfileAvatar(File avatar) throws IOException { - final StreamDetails streamDetails = Utils.createStreamDetailsFromFile(avatar); - accountManager.setProfileAvatar(account.getProfileKey(), streamDetails); - streamDetails.getStream().close(); + accountManager.setAccountAttributes(account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, account.getRegistrationLockPin(), account.getRegistrationLock(), getSelfUnidentifiedAccessKey(), false, capabilities, discoverableByPhoneNumber); } - public void removeProfileAvatar() throws IOException { - accountManager.setProfileAvatar(account.getProfileKey(), null); + public void setProfile(String name, File avatar) throws IOException { + try (final StreamDetails streamDetails = avatar == null ? null : Utils.createStreamDetailsFromFile(avatar)) { + accountManager.setVersionedProfile(account.getUuid(), account.getProfileKey(), name, streamDetails); + } } public void unregister() throws IOException { @@ -308,51 +323,6 @@ public class Manager implements Signal { account.save(); } - public String getDeviceLinkUri() throws TimeoutException, IOException { - if (account == null) { - createNewIdentity(); - } - account.setPassword(KeyUtils.createPassword()); - accountManager = getSignalServiceAccountManager(); - String uuid = accountManager.getNewDeviceUuid(); - - return Utils.createDeviceLinkUri(new Utils.DeviceLinkInfo(uuid, getIdentity().getPublicKey())); - } - - public void finishDeviceLink(String deviceName) throws IOException, InvalidKeyException, TimeoutException, UserAlreadyExists { - account.setSignalingKey(KeyUtils.createSignalingKey()); - SignalServiceAccountManager.NewDeviceRegistrationReturn ret = accountManager.finishNewDeviceRegistration(account.getSignalProtocolStore().getIdentityKeyPair(), account.getSignalingKey(), false, true, account.getSignalProtocolStore().getLocalRegistrationId(), deviceName); - - username = ret.getNumber(); - // TODO do this check before actually registering - if (SignalAccount.userExists(dataPath, username)) { - throw new UserAlreadyExists(username, SignalAccount.getFileName(dataPath, username)); - } - - // Create new account with the synced identity - byte[] profileKeyBytes = ret.getProfileKey(); - ProfileKey profileKey; - if (profileKeyBytes == null) { - profileKey = KeyUtils.createProfileKey(); - } else { - try { - profileKey = new ProfileKey(profileKeyBytes); - } catch (InvalidInputException e) { - throw new IOException("Received invalid profileKey", e); - } - } - account = SignalAccount.createLinkedAccount(dataPath, username, account.getPassword(), ret.getDeviceId(), ret.getIdentity(), account.getSignalProtocolStore().getLocalRegistrationId(), account.getSignalingKey(), profileKey); - - refreshPreKeys(); - - requestSyncGroups(); - requestSyncContacts(); - requestSyncBlocked(); - requestSyncConfiguration(); - - account.save(); - } - public List getLinkedDevices() throws IOException { List devices = accountManager.getDevices(); account.setMultiDevice(devices.size() > 1); @@ -374,7 +344,7 @@ public class Manager implements Signal { } private void addDevice(String deviceIdentifier, ECPublicKey deviceKey) throws IOException, InvalidKeyException { - IdentityKeyPair identityKeyPair = account.getSignalProtocolStore().getIdentityKeyPair(); + IdentityKeyPair identityKeyPair = getIdentityKeyPair(); String verificationCode = accountManager.getNewDeviceVerificationCode(); accountManager.addDevice(deviceIdentifier, deviceKey, identityKeyPair, Optional.of(account.getProfileKey().serialize()), verificationCode); @@ -383,10 +353,10 @@ public class Manager implements Signal { } private List generatePreKeys() { - List records = new ArrayList<>(BaseConfig.PREKEY_BATCH_SIZE); + List records = new ArrayList<>(ServiceConfig.PREKEY_BATCH_SIZE); final int offset = account.getPreKeyIdOffset(); - for (int i = 0; i < BaseConfig.PREKEY_BATCH_SIZE; i++) { + for (int i = 0; i < ServiceConfig.PREKEY_BATCH_SIZE; i++) { int preKeyId = (offset + i) % Medium.MAX_VALUE; ECKeyPair keyPair = Curve.generateKeyPair(); PreKeyRecord record = new PreKeyRecord(preKeyId, keyPair); @@ -419,11 +389,15 @@ public class Manager implements Signal { verificationCode = verificationCode.replace("-", ""); account.setSignalingKey(KeyUtils.createSignalingKey()); // TODO make unrestricted unidentified access configurable - accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, null, getSelfUnidentifiedAccessKey(), false, capabilities); + VerifyAccountResponse response = accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, null, getSelfUnidentifiedAccessKey(), false, capabilities, discoverableByPhoneNumber); + UUID uuid = UuidUtil.parseOrNull(response.getUuid()); + // TODO response.isStorageCapable() //accountManager.setGcmId(Optional.of(GoogleCloudMessaging.getInstance(this).register(REGISTRATION_ID))); account.setRegistered(true); + account.setUuid(uuid); account.setRegistrationLockPin(pin); + account.getSignalProtocolStore().saveIdentity(account.getSelfAddress(), getIdentityKeyPair().getPublicKey(), TrustLevel.TRUSTED_VERIFIED); refreshPreKeys(); account.save(); @@ -435,44 +409,86 @@ public class Manager implements Signal { throw new RuntimeException("Not implemented anymore, will be replaced with KBS"); } else { account.setRegistrationLockPin(null); - accountManager.removeV1Pin(); + accountManager.removeRegistrationLockV1(); } account.save(); } - private void refreshPreKeys() throws IOException { + void refreshPreKeys() throws IOException { List oneTimePreKeys = generatePreKeys(); - final IdentityKeyPair identityKeyPair = account.getSignalProtocolStore().getIdentityKeyPair(); + final IdentityKeyPair identityKeyPair = getIdentityKeyPair(); SignedPreKeyRecord signedPreKeyRecord = generateSignedPreKey(identityKeyPair); - accountManager.setPreKeys(getIdentity(), signedPreKeyRecord, oneTimePreKeys); + accountManager.setPreKeys(identityKeyPair.getPublicKey(), signedPreKeyRecord, oneTimePreKeys); } private SignalServiceMessageReceiver getMessageReceiver() { - return new SignalServiceMessageReceiver(BaseConfig.serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), account.getDeviceId(), account.getSignalingKey(), BaseConfig.USER_AGENT, null, timer); + // TODO implement ZkGroup support + final ClientZkProfileOperations clientZkProfileOperations = null; + return new SignalServiceMessageReceiver(serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), account.getDeviceId(), account.getSignalingKey(), userAgent, null, timer, clientZkProfileOperations); } private SignalServiceMessageSender getMessageSender() { - return new SignalServiceMessageSender(BaseConfig.serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), - account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent()); + // TODO implement ZkGroup support + final ClientZkProfileOperations clientZkProfileOperations = null; + final boolean attachmentsV3 = false; + final ExecutorService executor = null; + return new SignalServiceMessageSender(serviceConfiguration, account.getUuid(), account.getUsername(), account.getPassword(), + account.getDeviceId(), account.getSignalProtocolStore(), userAgent, account.isMultiDevice(), attachmentsV3, Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent(), clientZkProfileOperations, executor); } - private SignalServiceProfile getRecipientProfile(SignalServiceAddress address, Optional unidentifiedAccess) throws IOException { + private SignalServiceProfile getEncryptedRecipientProfile(SignalServiceAddress address, Optional unidentifiedAccess) throws IOException { SignalServiceMessagePipe pipe = unidentifiedMessagePipe != null && unidentifiedAccess.isPresent() ? unidentifiedMessagePipe : messagePipe; if (pipe != null) { try { - return pipe.getProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile(); - } catch (IOException ignored) { + return pipe.getProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).get(10, TimeUnit.SECONDS).getProfile(); + } catch (IOException | InterruptedException | ExecutionException | TimeoutException ignored) { } } SignalServiceMessageReceiver receiver = getMessageReceiver(); try { - return receiver.retrieveProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile(); - } catch (VerificationFailedException e) { - throw new AssertionError(e); + return receiver.retrieveProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).get(10, TimeUnit.SECONDS).getProfile(); + } catch (InterruptedException | ExecutionException | TimeoutException e) { + throw new IOException("Failed to retrieve profile", e); + } + } + + private SignalProfile getRecipientProfile(SignalServiceAddress address, Optional unidentifiedAccess, ProfileKey profileKey) throws IOException { + SignalProfileEntry profileEntry = account.getProfileStore().getProfile(address); + long now = new Date().getTime(); + // Profiles are cache for 24h before retrieving them again + if (profileEntry == null || profileEntry.getProfile() == null || now - profileEntry.getLastUpdateTimestamp() > 24 * 60 * 60 * 1000) { + SignalProfile profile = retrieveRecipientProfile(address, unidentifiedAccess, profileKey); + account.getProfileStore().updateProfile(address, profileKey, now, profile); + return profile; + } + return profileEntry.getProfile(); + } + + private SignalProfile retrieveRecipientProfile(SignalServiceAddress address, Optional unidentifiedAccess, ProfileKey profileKey) throws IOException { + final SignalServiceProfile encryptedProfile = getEncryptedRecipientProfile(address, unidentifiedAccess); + + File avatarFile = null; + try { + avatarFile = encryptedProfile.getAvatar() == null ? null : retrieveProfileAvatar(address, encryptedProfile.getAvatar(), profileKey); + } catch (Throwable e) { + System.err.println("Failed to retrieve profile avatar, ignoring: " + e.getMessage()); + } + + ProfileCipher profileCipher = new ProfileCipher(profileKey); + try { + return new SignalProfile( + encryptedProfile.getIdentityKey(), + encryptedProfile.getName() == null ? null : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName()))), + avatarFile, + encryptedProfile.getUnidentifiedAccess() == null || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess())) ? null : encryptedProfile.getUnidentifiedAccess(), + encryptedProfile.isUnrestrictedUnidentifiedAccess(), + encryptedProfile.getCapabilities()); + } catch (InvalidCiphertextException e) { + return null; } } @@ -499,22 +515,19 @@ public class Manager implements Signal { if (g == null) { throw new GroupNotFoundException(groupId); } - for (String member : g.members) { - if (member.equals(account.getUsername())) { - return g; - } + if (!g.isMember(account.getSelfAddress())) { + throw new NotAGroupMemberException(groupId, g.name); } - throw new NotAGroupMemberException(groupId, g.name); + return g; } public List getGroups() { return account.getGroupStore().getGroups(); } - @Override - public void sendGroupMessage(String messageText, List attachments, + public long sendGroupMessage(String messageText, List attachments, byte[] groupId) - throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException { + throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException { final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); if (attachments != null) { messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments)); @@ -525,26 +538,20 @@ public class Manager implements Signal { .build(); messageBuilder.asGroupMessage(group); } - ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(groupId)); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); - } final GroupInfo g = getGroupForSending(groupId); - final Collection membersSend = getSignalServiceAddresses(g.members); - // Don't send group message to ourself - membersSend.remove(account.getSelfAddress()); - sendMessageLegacy(messageBuilder, membersSend); + messageBuilder.withExpiration(g.messageExpirationTime); + + return sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress())); } - public void sendGroupMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor, + public void sendGroupMessageReaction(String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, byte[] groupId) - throws IOException, EncapsulatedExceptions, AttachmentInvalidException, InvalidNumberException { - SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp); + throws IOException, EncapsulatedExceptions, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp); final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() - .withReaction(reaction) - .withProfileKey(account.getProfileKey().serialize()); + .withReaction(reaction); if (groupId != null) { SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER) .withId(groupId) @@ -552,13 +559,10 @@ public class Manager implements Signal { messageBuilder.asGroupMessage(group); } final GroupInfo g = getGroupForSending(groupId); - final Collection membersSend = getSignalServiceAddresses(g.members); - // Don't send group message to ourself - membersSend.remove(account.getSelfAddress()); - sendMessageLegacy(messageBuilder, membersSend); + sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress())); } - public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, InvalidNumberException { + public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, NotAGroupMemberException { SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT) .withId(groupId) .build(); @@ -567,18 +571,18 @@ public class Manager implements Signal { .asGroupMessage(group); final GroupInfo g = getGroupForSending(groupId); - g.members.remove(account.getUsername()); + g.removeMember(account.getSelfAddress()); account.getGroupStore().updateGroup(g); - sendMessageLegacy(messageBuilder, getSignalServiceAddresses(g.members)); + sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress())); } - private byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException { + private byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException { GroupInfo g; if (groupId == null) { // Create new group g = new GroupInfo(KeyUtils.createGroupId()); - g.members.add(account.getUsername()); + g.addMembers(Collections.singleton(account.getSelfAddress())); } else { g = getGroupForSending(groupId); } @@ -588,29 +592,28 @@ public class Manager implements Signal { } if (members != null) { - Set newMembers = new HashSet<>(); - for (String member : members) { - member = Utils.canonicalizeNumber(member, account.getUsername()); - if (g.members.contains(member)) { + final Set newE164Members = new HashSet<>(); + for (SignalServiceAddress member : members) { + if (g.isMember(member) || !member.getNumber().isPresent()) { continue; } - newMembers.add(member); - g.members.add(member); + newE164Members.add(member.getNumber().get()); } - final List contacts = accountManager.getContacts(newMembers); - if (contacts.size() != newMembers.size()) { + + final List contacts = accountManager.getContacts(newE164Members); + if (contacts.size() != newE164Members.size()) { // Some of the new members are not registered on Signal for (ContactTokenDetails contact : contacts) { - newMembers.remove(contact.getNumber()); + newE164Members.remove(contact.getNumber()); } - System.err.println("Failed to add members " + Util.join(", ", newMembers) + " to group: Not registered on Signal"); - System.err.println("Aborting…"); - System.exit(1); + throw new IOException("Failed to add members " + Util.join(", ", newE164Members) + " to group: Not registered on Signal"); } + + g.addMembers(members); } if (avatarFile != null) { - IOUtils.createPrivateDirectories(avatarsPath); + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); File aFile = getGroupAvatarFile(g.groupId); Files.copy(Paths.get(avatarFile), aFile.toPath(), StandardCopyOption.REPLACE_EXISTING); } @@ -619,20 +622,17 @@ public class Manager implements Signal { SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g); - final Collection membersSend = getSignalServiceAddresses(g.members); - // Don't send group message to ourself - membersSend.remove(account.getSelfAddress()); - sendMessageLegacy(messageBuilder, membersSend); + sendMessageLegacy(messageBuilder, g.getMembersWithout(account.getSelfAddress())); return g.groupId; } - private void sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions { + void sendUpdateGroupMessage(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException { if (groupId == null) { return; } GroupInfo g = getGroupForSending(groupId); - if (!g.members.contains(recipient.getNumber().get())) { + if (!g.isMember(recipient)) { return; } @@ -642,7 +642,7 @@ public class Manager implements Signal { sendMessageLegacy(messageBuilder, Collections.singleton(recipient)); } - private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) { + private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) throws AttachmentInvalidException { SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE) .withId(g.groupId) .withName(g.name) @@ -657,18 +657,12 @@ public class Manager implements Signal { } } - SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() - .asGroupMessage(group.build()); - - ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(g.groupId)); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); - } - - return messageBuilder; + return SignalServiceDataMessage.newBuilder() + .asGroupMessage(group.build()) + .withExpiration(g.messageExpirationTime); } - private void sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions { + void sendGroupInfoRequest(byte[] groupId, SignalServiceAddress recipient) throws IOException, EncapsulatedExceptions { if (groupId == null) { return; } @@ -679,25 +673,19 @@ public class Manager implements Signal { SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() .asGroupMessage(group.build()); - ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(groupId)); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); - } - // Send group info request message to the recipient who sent us a message with this groupId sendMessageLegacy(messageBuilder, Collections.singleton(recipient)); } - @Override - public void sendMessage(String message, List attachments, String recipient) - throws EncapsulatedExceptions, AttachmentInvalidException, IOException, InvalidNumberException { - List recipients = new ArrayList<>(1); - recipients.add(recipient); - sendMessage(message, attachments, recipients); + void sendReceipt(SignalServiceAddress remoteAddress, long messageId) throws IOException, UntrustedIdentityException { + SignalServiceReceiptMessage receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.DELIVERY, + Collections.singletonList(messageId), + System.currentTimeMillis()); + + getMessageSender().sendReceipt(remoteAddress, getAccessFor(remoteAddress), receiptMessage); } - @Override - public void sendMessage(String messageText, List attachments, + public long sendMessage(String messageText, List attachments, List recipients) throws IOException, EncapsulatedExceptions, AttachmentInvalidException, InvalidNumberException { final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); @@ -717,32 +705,36 @@ public class Manager implements Signal { messageBuilder.withAttachments(attachmentPointers); } - messageBuilder.withProfileKey(account.getProfileKey().serialize()); - sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients)); + return sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients)); } - public void sendMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor, + public void sendMessageReaction(String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, List recipients) - throws IOException, EncapsulatedExceptions, AttachmentInvalidException, InvalidNumberException { - SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp); + throws IOException, EncapsulatedExceptions, InvalidNumberException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, canonicalizeAndResolveSignalServiceAddress(targetAuthor), targetSentTimestamp); final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() - .withReaction(reaction) - .withProfileKey(account.getProfileKey().serialize()); + .withReaction(reaction); sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients)); } - @Override public void sendEndSessionMessage(List recipients) throws IOException, EncapsulatedExceptions, InvalidNumberException { SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() .asEndSessionMessage(); - sendMessageLegacy(messageBuilder, getSignalServiceAddresses(recipients)); + final Collection signalServiceAddresses = getSignalServiceAddresses(recipients); + try { + sendMessageLegacy(messageBuilder, signalServiceAddresses); + } catch (Exception e) { + for (SignalServiceAddress address : signalServiceAddresses) { + handleEndSession(address); + } + account.save(); + throw e; + } } - @Override public String getContactName(String number) throws InvalidNumberException { - String canonicalizedNumber = Utils.canonicalizeNumber(number, account.getUsername()); - ContactInfo contact = account.getContactStore().getContact(canonicalizedNumber); + ContactInfo contact = account.getContactStore().getContact(canonicalizeAndResolveSignalServiceAddress(number)); if (contact == null) { return ""; } else { @@ -750,105 +742,90 @@ public class Manager implements Signal { } } - @Override public void setContactName(String number, String name) throws InvalidNumberException { - String canonicalizedNumber = Utils.canonicalizeNumber(number, account.getUsername()); - ContactInfo contact = account.getContactStore().getContact(canonicalizedNumber); + final SignalServiceAddress address = canonicalizeAndResolveSignalServiceAddress(number); + ContactInfo contact = account.getContactStore().getContact(address); if (contact == null) { - contact = new ContactInfo(); - contact.number = canonicalizedNumber; - System.err.println("Add contact " + canonicalizedNumber + " named " + name); - } else { - System.err.println("Updating contact " + canonicalizedNumber + " name " + contact.name + " -> " + name); + contact = new ContactInfo(address); } contact.name = name; account.getContactStore().updateContact(contact); account.save(); } - @Override public void setContactBlocked(String number, boolean blocked) throws InvalidNumberException { - number = Utils.canonicalizeNumber(number, account.getUsername()); - ContactInfo contact = account.getContactStore().getContact(number); + setContactBlocked(canonicalizeAndResolveSignalServiceAddress(number), blocked); + } + + private void setContactBlocked(SignalServiceAddress address, boolean blocked) { + ContactInfo contact = account.getContactStore().getContact(address); if (contact == null) { - contact = new ContactInfo(); - contact.number = number; - System.err.println("Adding and " + (blocked ? "blocking" : "unblocking") + " contact " + number); - } else { - System.err.println((blocked ? "Blocking" : "Unblocking") + " contact " + number); + contact = new ContactInfo(address); } contact.blocked = blocked; account.getContactStore().updateContact(contact); account.save(); } - @Override public void setGroupBlocked(final byte[] groupId, final boolean blocked) throws GroupNotFoundException { GroupInfo group = getGroup(groupId); if (group == null) { throw new GroupNotFoundException(groupId); - } else { - System.err.println((blocked ? "Blocking" : "Unblocking") + " group " + Base64.encodeBytes(groupId)); - group.blocked = blocked; - account.getGroupStore().updateGroup(group); - account.save(); } - } - @Override - public List getGroupIds() { - List groups = getGroups(); - List ids = new ArrayList<>(groups.size()); - for (GroupInfo group : groups) { - ids.add(group.groupId); - } - return ids; - } - - @Override - public String getGroupName(byte[] groupId) { - GroupInfo group = getGroup(groupId); - if (group == null) { - return ""; - } else { - return group.name; - } - } - - @Override - public List getGroupMembers(byte[] groupId) { - GroupInfo group = getGroup(groupId); - if (group == null) { - return new ArrayList<>(); - } else { - return new ArrayList<>(group.members); - } + group.blocked = blocked; + account.getGroupStore().updateGroup(group); + account.save(); } - @Override - public byte[] updateGroup(byte[] groupId, String name, List members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException { + public byte[] updateGroup(byte[] groupId, String name, List members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException { if (groupId.length == 0) { groupId = null; } if (name.isEmpty()) { name = null; } - if (members.size() == 0) { + if (members.isEmpty()) { members = null; } if (avatar.isEmpty()) { avatar = null; } - return sendUpdateGroupMessage(groupId, name, members, avatar); + return sendUpdateGroupMessage(groupId, name, members == null ? null : getSignalServiceAddresses(members), avatar); + } + + /** + * Change the expiration timer for a contact + */ + public void setExpirationTimer(SignalServiceAddress address, int messageExpirationTimer) throws IOException { + ContactInfo contact = account.getContactStore().getContact(address); + contact.messageExpirationTime = messageExpirationTimer; + account.getContactStore().updateContact(contact); + sendExpirationTimerUpdate(address); + account.save(); + } + + private void sendExpirationTimerUpdate(SignalServiceAddress address) throws IOException { + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .asExpirationUpdate(); + sendMessage(messageBuilder, Collections.singleton(address)); + } + + /** + * Change the expiration timer for a contact + */ + public void setExpirationTimer(String number, int messageExpirationTimer) throws IOException, InvalidNumberException { + SignalServiceAddress address = canonicalizeAndResolveSignalServiceAddress(number); + setExpirationTimer(address, messageExpirationTimer); } /** - * Change the expiration timer for a thread (number of groupId) + * Change the expiration timer for a group */ - public void setExpirationTimer(String numberOrGroupId, int messageExpirationTimer) { - ThreadInfo thread = account.getThreadStore().getThread(numberOrGroupId); - thread.messageExpirationTime = messageExpirationTimer; - account.getThreadStore().updateThread(thread); + public void setExpirationTimer(byte[] groupId, int messageExpirationTimer) { + GroupInfo g = account.getGroupStore().getGroup(groupId); + g.messageExpirationTime = messageExpirationTimer; + account.getGroupStore().updateGroup(g); } /** @@ -909,7 +886,8 @@ public class Manager implements Signal { throw new StickerPackInvalidException("Could not find find " + sticker.file); } - StickerInfo stickerInfo = new StickerInfo(data.first(), data.second(), Optional.fromNullable(sticker.emoji).or("")); + String contentType = Utils.getFileMimeType(new File(sticker.file), null); + StickerInfo stickerInfo = new StickerInfo(data.first(), data.second(), Optional.fromNullable(sticker.emoji).or(""), contentType); stickers.add(stickerInfo); } @@ -926,7 +904,8 @@ public class Manager implements Signal { throw new StickerPackInvalidException("Could not find find " + pack.cover.file); } - cover = new StickerInfo(data.first(), data.second(), Optional.fromNullable(pack.cover.emoji).or("")); + String contentType = Utils.getFileMimeType(new File(pack.cover.file), null); + cover = new StickerInfo(data.first(), data.second(), Optional.fromNullable(pack.cover.emoji).or(""), contentType); } return new SignalServiceStickerManifestUpload( @@ -956,7 +935,7 @@ public class Manager implements Signal { } } - private void requestSyncGroups() throws IOException { + void requestSyncGroups() throws IOException { SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS).build(); SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r)); try { @@ -966,7 +945,7 @@ public class Manager implements Signal { } } - private void requestSyncContacts() throws IOException { + void requestSyncContacts() throws IOException { SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS).build(); SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r)); try { @@ -976,7 +955,7 @@ public class Manager implements Signal { } } - private void requestSyncBlocked() throws IOException { + void requestSyncBlocked() throws IOException { SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED).build(); SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r)); try { @@ -986,7 +965,7 @@ public class Manager implements Signal { } } - private void requestSyncConfiguration() throws IOException { + void requestSyncConfiguration() throws IOException { SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION).build(); SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r)); try { @@ -996,8 +975,16 @@ public class Manager implements Signal { } } - private byte[] getSenderCertificate() throws IOException { - byte[] certificate = accountManager.getSenderCertificate(); + private byte[] getSenderCertificate() { + // TODO support UUID capable sender certificates + // byte[] certificate = accountManager.getSenderCertificateForPhoneNumberPrivacy(); + byte[] certificate; + try { + certificate = accountManager.getSenderCertificate(); + } catch (IOException e) { + System.err.println("Failed to get sender certificate: " + e); + return null; + } // TODO cache for a day return certificate; } @@ -1006,33 +993,24 @@ public class Manager implements Signal { return UnidentifiedAccess.deriveAccessKeyFrom(account.getProfileKey()); } - private static SignalProfile decryptProfile(SignalServiceProfile encryptedProfile, ProfileKey profileKey) throws IOException { - ProfileCipher profileCipher = new ProfileCipher(profileKey); - try { - return new SignalProfile( - encryptedProfile.getIdentityKey(), - encryptedProfile.getName() == null ? null : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName()))), - encryptedProfile.getAvatar(), - encryptedProfile.getUnidentifiedAccess() == null || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess())) ? null : encryptedProfile.getUnidentifiedAccess(), - encryptedProfile.isUnrestrictedUnidentifiedAccess() - ); - } catch (InvalidCiphertextException e) { - return null; - } - } - - private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) throws IOException { - ContactInfo contact = account.getContactStore().getContact(recipient.getNumber().get()); + private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) { + ContactInfo contact = account.getContactStore().getContact(recipient); if (contact == null || contact.profileKey == null) { return null; } ProfileKey theirProfileKey; try { theirProfileKey = new ProfileKey(Base64.decode(contact.profileKey)); - } catch (InvalidInputException e) { + } catch (InvalidInputException | IOException e) { throw new AssertionError(e); } - SignalProfile targetProfile = decryptProfile(getRecipientProfile(recipient, Optional.absent()), theirProfileKey); + SignalProfile targetProfile; + try { + targetProfile = getRecipientProfile(recipient, Optional.absent(), theirProfileKey); + } catch (IOException e) { + System.err.println("Failed to get recipient profile: " + e); + return null; + } if (targetProfile == null || targetProfile.getUnidentifiedAccess() == null) { return null; @@ -1045,7 +1023,7 @@ public class Manager implements Signal { return UnidentifiedAccess.deriveAccessKeyFrom(theirProfileKey); } - private Optional getAccessForSync() throws IOException { + private Optional getAccessForSync() { byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey(); byte[] selfUnidentifiedAccessCertificate = getSenderCertificate(); @@ -1063,7 +1041,7 @@ public class Manager implements Signal { } } - private List> getAccessFor(Collection recipients) throws IOException { + private List> getAccessFor(Collection recipients) { List> result = new ArrayList<>(recipients.size()); for (SignalServiceAddress recipient : recipients) { result.add(getAccessFor(recipient)); @@ -1071,7 +1049,7 @@ public class Manager implements Signal { return result; } - private Optional getAccessFor(SignalServiceAddress recipient) throws IOException { + private Optional getAccessFor(SignalServiceAddress recipient) { byte[] recipientUnidentifiedAccessKey = getTargetUnidentifiedAccessKey(recipient); byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey(); byte[] selfUnidentifiedAccessCertificate = getSenderCertificate(); @@ -1090,13 +1068,23 @@ public class Manager implements Signal { } } + private Optional getUnidentifiedAccess(SignalServiceAddress recipient) { + Optional unidentifiedAccess = getAccessFor(recipient); + + if (unidentifiedAccess.isPresent()) { + return unidentifiedAccess.get().getTargetUnidentifiedAccess(); + } + + return Optional.absent(); + } + private void sendSyncMessage(SignalServiceSyncMessage message) throws IOException, UntrustedIdentityException { SignalServiceMessageSender messageSender = getMessageSender(); try { messageSender.sendMessage(message, getAccessForSync()); } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED); throw e; } } @@ -1104,8 +1092,10 @@ public class Manager implements Signal { /** * This method throws an EncapsulatedExceptions exception instead of returning a list of SendMessageResult. */ - private void sendMessageLegacy(SignalServiceDataMessage.Builder messageBuilder, Collection recipients) + private long sendMessageLegacy(SignalServiceDataMessage.Builder messageBuilder, Collection recipients) throws EncapsulatedExceptions, IOException { + final long timestamp = System.currentTimeMillis(); + messageBuilder.withTimestamp(timestamp); List results = sendMessage(messageBuilder, recipients); List untrustedIdentities = new LinkedList<>(); @@ -1114,30 +1104,24 @@ public class Manager implements Signal { for (SendMessageResult result : results) { if (result.isUnregisteredFailure()) { - unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getNumber().get(), null)); + unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getLegacyIdentifier(), null)); } else if (result.isNetworkFailure()) { - networkExceptions.add(new NetworkFailureException(result.getAddress().getNumber().get(), null)); + networkExceptions.add(new NetworkFailureException(result.getAddress().getLegacyIdentifier(), null)); } else if (result.getIdentityFailure() != null) { - untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getNumber().get(), result.getIdentityFailure().getIdentityKey())); + untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getLegacyIdentifier(), result.getIdentityFailure().getIdentityKey())); } } if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) { throw new EncapsulatedExceptions(untrustedIdentities, unregisteredUsers, networkExceptions); } + return timestamp; } private Collection getSignalServiceAddresses(Collection numbers) throws InvalidNumberException { final Set signalServiceAddresses = new HashSet<>(numbers.size()); - final String username = account.getUsername(); for (String number : numbers) { - String canonicalizedNumber = Utils.canonicalizeNumber(number, username); - if (canonicalizedNumber.equals(username)) { - signalServiceAddresses.add(account.getSelfAddress()); - } else { - // TODO get corresponding uuid - signalServiceAddresses.add(new SignalServiceAddress(null, canonicalizedNumber)); - } + signalServiceAddresses.add(canonicalizeAndResolveSignalServiceAddress(number)); } return signalServiceAddresses; } @@ -1152,59 +1136,39 @@ public class Manager implements Signal { } SignalServiceDataMessage message = null; try { - SignalServiceMessageSender messageSender = getMessageSender(); - message = messageBuilder.build(); - if (message.getGroupInfo().isPresent()) { + if (message.getGroupContext().isPresent()) { try { + SignalServiceMessageSender messageSender = getMessageSender(); final boolean isRecipientUpdate = false; List result = messageSender.sendMessage(new ArrayList<>(recipients), getAccessFor(recipients), isRecipientUpdate, message); for (SendMessageResult r : result) { if (r.getIdentityFailure() != null) { - account.getSignalProtocolStore().saveIdentity(r.getAddress().getNumber().get(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(r.getAddress(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED); } } return result; } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED); return Collections.emptyList(); } - } else if (recipients.size() == 1 && recipients.contains(account.getSelfAddress())) { - SignalServiceAddress recipient = account.getSelfAddress(); - final Optional unidentifiedAccess = getAccessFor(recipient); - SentTranscriptMessage transcript = new SentTranscriptMessage(Optional.of(recipient), - message.getTimestamp(), - message, - message.getExpiresInSeconds(), - Collections.singletonMap(recipient, unidentifiedAccess.isPresent()), - false); - SignalServiceSyncMessage syncMessage = SignalServiceSyncMessage.forSentTranscript(transcript); - - List results = new ArrayList<>(recipients.size()); - try { - messageSender.sendMessage(syncMessage, unidentifiedAccess); - } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); - results.add(SendMessageResult.identityFailure(recipient, e.getIdentityKey())); - } - return results; } else { // Send to all individually, so sync messages are sent correctly List results = new ArrayList<>(recipients.size()); for (SignalServiceAddress address : recipients) { - ThreadInfo thread = account.getThreadStore().getThread(address.getNumber().get()); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); + ContactInfo contact = account.getContactStore().getContact(address); + if (contact != null) { + messageBuilder.withExpiration(contact.messageExpirationTime); + messageBuilder.withProfileKey(account.getProfileKey().serialize()); } else { messageBuilder.withExpiration(0); + messageBuilder.withProfileKey(null); } message = messageBuilder.build(); - try { - SendMessageResult result = messageSender.sendMessage(address, getAccessFor(address), message); - results.add(result); - } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); - results.add(SendMessageResult.identityFailure(address, e.getIdentityKey())); + if (address.matches(account.getSelfAddress())) { + results.add(sendSelfMessage(message)); + } else { + results.add(sendMessage(address, message)); } } return results; @@ -1212,33 +1176,69 @@ public class Manager implements Signal { } finally { if (message != null && message.isEndSession()) { for (SignalServiceAddress recipient : recipients) { - handleEndSession(recipient.getNumber().get()); + handleEndSession(recipient); } } account.save(); } } - private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, ProtocolUntrustedIdentityException, SelfSendException, UnsupportedDataMessageException { + private SendMessageResult sendSelfMessage(SignalServiceDataMessage message) throws IOException { + SignalServiceMessageSender messageSender = getMessageSender(); + + SignalServiceAddress recipient = account.getSelfAddress(); + + final Optional unidentifiedAccess = getAccessFor(recipient); + SentTranscriptMessage transcript = new SentTranscriptMessage(Optional.of(recipient), + message.getTimestamp(), + message, + message.getExpiresInSeconds(), + Collections.singletonMap(recipient, unidentifiedAccess.isPresent()), + false); + SignalServiceSyncMessage syncMessage = SignalServiceSyncMessage.forSentTranscript(transcript); + + try { + messageSender.sendMessage(syncMessage, unidentifiedAccess); + return SendMessageResult.success(recipient, unidentifiedAccess.isPresent(), false); + } catch (UntrustedIdentityException e) { + account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED); + return SendMessageResult.identityFailure(recipient, e.getIdentityKey()); + } + } + + private SendMessageResult sendMessage(SignalServiceAddress address, SignalServiceDataMessage message) throws IOException { + SignalServiceMessageSender messageSender = getMessageSender(); + + try { + return messageSender.sendMessage(address, getAccessFor(address), message); + } catch (UntrustedIdentityException e) { + account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), e.getIdentityKey(), TrustLevel.UNTRUSTED); + return SendMessageResult.identityFailure(address, e.getIdentityKey()); + } + } + + private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, SelfSendException, UnsupportedDataMessageException, org.whispersystems.libsignal.UntrustedIdentityException { SignalServiceCipher cipher = new SignalServiceCipher(account.getSelfAddress(), account.getSignalProtocolStore(), Utils.getCertificateValidator()); try { return cipher.decrypt(envelope); } catch (ProtocolUntrustedIdentityException e) { - // TODO We don't get the new untrusted identity from ProtocolUntrustedIdentityException anymore ... we need to get it from somewhere else -// account.getSignalProtocolStore().saveIdentity(e.getSender(), e.getUntrustedIdentity(), TrustLevel.UNTRUSTED); - throw e; + if (e.getCause() instanceof org.whispersystems.libsignal.UntrustedIdentityException) { + org.whispersystems.libsignal.UntrustedIdentityException identityException = (org.whispersystems.libsignal.UntrustedIdentityException) e.getCause(); + account.getSignalProtocolStore().saveIdentity(resolveSignalServiceAddress(identityException.getName()), identityException.getUntrustedIdentity(), TrustLevel.UNTRUSTED); + throw identityException; + } + throw new AssertionError(e); } } - private void handleEndSession(String source) { + private void handleEndSession(SignalServiceAddress source) { account.getSignalProtocolStore().deleteAllSessions(source); } - private void handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, SignalServiceAddress source, SignalServiceAddress destination, boolean ignoreAttachments) { - String threadId; - if (message.getGroupInfo().isPresent()) { - SignalServiceGroup groupInfo = message.getGroupInfo().get(); - threadId = Base64.encodeBytes(groupInfo.getGroupId()); + private List handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, SignalServiceAddress source, SignalServiceAddress destination, boolean ignoreAttachments) { + List actions = new ArrayList<>(); + if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId()); switch (groupInfo.getType()) { case UPDATE: @@ -1251,8 +1251,8 @@ public class Manager implements Signal { if (avatar.isPointer()) { try { retrieveGroupAvatarAttachment(avatar.asPointer(), group.groupId); - } catch (IOException | InvalidMessageException e) { - System.err.println("Failed to retrieve group avatar (" + avatar.asPointer().getId() + "): " + e.getMessage()); + } catch (IOException | InvalidMessageException | MissingConfigurationException e) { + System.err.println("Failed to retrieve group avatar (" + avatar.asPointer().getRemoteId() + "): " + e.getMessage()); } } } @@ -1262,63 +1262,56 @@ public class Manager implements Signal { } if (groupInfo.getMembers().isPresent()) { - group.addMembers(groupInfo.getMembers().get()); + group.addMembers(groupInfo.getMembers().get() + .stream() + .map(this::resolveSignalServiceAddress) + .collect(Collectors.toSet())); } account.getGroupStore().updateGroup(group); break; case DELIVER: - if (group == null) { - try { - sendGroupInfoRequest(groupInfo.getGroupId(), source); - } catch (IOException | EncapsulatedExceptions e) { - e.printStackTrace(); - } + if (group == null && !isSync) { + actions.add(new SendGroupInfoRequestAction(source, groupInfo.getGroupId())); } break; case QUIT: - if (group == null) { - try { - sendGroupInfoRequest(groupInfo.getGroupId(), source); - } catch (IOException | EncapsulatedExceptions e) { - e.printStackTrace(); - } - } else { - group.members.remove(source.getNumber().get()); + if (group != null) { + group.removeMember(source); account.getGroupStore().updateGroup(group); } break; case REQUEST_INFO: - if (group != null) { - try { - sendUpdateGroupMessage(groupInfo.getGroupId(), source); - } catch (IOException | EncapsulatedExceptions e) { - e.printStackTrace(); - } catch (NotAGroupMemberException e) { - // We have left this group, so don't send a group update message - } + if (group != null && !isSync) { + actions.add(new SendGroupUpdateAction(source, group.groupId)); } break; } - } else { - if (isSync) { - threadId = destination.getNumber().get(); - } else { - threadId = source.getNumber().get(); - } } + final SignalServiceAddress conversationPartnerAddress = isSync ? destination : source; if (message.isEndSession()) { - handleEndSession(isSync ? destination.getNumber().get() : source.getNumber().get()); + handleEndSession(conversationPartnerAddress); } if (message.isExpirationUpdate() || message.getBody().isPresent()) { - ThreadInfo thread = account.getThreadStore().getThread(threadId); - if (thread == null) { - thread = new ThreadInfo(); - thread.id = threadId; - } - if (thread.messageExpirationTime != message.getExpiresInSeconds()) { - thread.messageExpirationTime = message.getExpiresInSeconds(); - account.getThreadStore().updateThread(thread); + if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); + GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId()); + if (group == null) { + group = new GroupInfo(groupInfo.getGroupId()); + } + if (group.messageExpirationTime != message.getExpiresInSeconds()) { + group.messageExpirationTime = message.getExpiresInSeconds(); + account.getGroupStore().updateGroup(group); + } + } else { + ContactInfo contact = account.getContactStore().getContact(conversationPartnerAddress); + if (contact == null) { + contact = new ContactInfo(conversationPartnerAddress); + } + if (contact.messageExpirationTime != message.getExpiresInSeconds()) { + contact.messageExpirationTime = message.getExpiresInSeconds(); + account.getContactStore().updateContact(contact); + } } } if (message.getAttachments().isPresent() && !ignoreAttachments) { @@ -1326,26 +1319,31 @@ public class Manager implements Signal { if (attachment.isPointer()) { try { retrieveAttachment(attachment.asPointer()); - } catch (IOException | InvalidMessageException e) { - System.err.println("Failed to retrieve attachment (" + attachment.asPointer().getId() + "): " + e.getMessage()); + } catch (IOException | InvalidMessageException | MissingConfigurationException e) { + System.err.println("Failed to retrieve attachment (" + attachment.asPointer().getRemoteId() + "): " + e.getMessage()); } } } } if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) { - if (source.equals(account.getSelfAddress())) { + if (source.matches(account.getSelfAddress())) { try { this.account.setProfileKey(new ProfileKey(message.getProfileKey().get())); } catch (InvalidInputException ignored) { } + ContactInfo contact = account.getContactStore().getContact(source); + if (contact != null) { + contact.profileKey = Base64.encodeBytes(message.getProfileKey().get()); + account.getContactStore().updateContact(contact); + } + } else { + ContactInfo contact = account.getContactStore().getContact(source); + if (contact == null) { + contact = new ContactInfo(source); + } + contact.profileKey = Base64.encodeBytes(message.getProfileKey().get()); + account.getContactStore().updateContact(contact); } - ContactInfo contact = account.getContactStore().getContact(source.getNumber().get()); - if (contact == null) { - contact = new ContactInfo(); - contact.number = source.getNumber().get(); - } - contact.profileKey = Base64.encodeBytes(message.getProfileKey().get()); - account.getContactStore().updateContact(contact); } if (message.getPreviews().isPresent()) { final List previews = message.getPreviews().get(); @@ -1354,12 +1352,13 @@ public class Manager implements Signal { SignalServiceAttachmentPointer attachment = preview.getImage().get().asPointer(); try { retrieveAttachment(attachment); - } catch (IOException | InvalidMessageException e) { - System.err.println("Failed to retrieve attachment (" + attachment.getId() + "): " + e.getMessage()); + } catch (IOException | InvalidMessageException | MissingConfigurationException e) { + System.err.println("Failed to retrieve attachment (" + attachment.getRemoteId() + "): " + e.getMessage()); } } } } + return actions; } private void retryFailedReceivedMessages(ReceiveMessageHandler handler, boolean ignoreAttachments) { @@ -1369,6 +1368,7 @@ public class Manager implements Signal { } for (final File dir : Objects.requireNonNull(cachePath.listFiles())) { if (!dir.isDirectory()) { + retryFailedReceivedMessage(handler, ignoreAttachments, dir); continue; } @@ -1376,35 +1376,46 @@ public class Manager implements Signal { if (!fileEntry.isFile()) { continue; } - SignalServiceEnvelope envelope; + retryFailedReceivedMessage(handler, ignoreAttachments, fileEntry); + } + // Try to delete directory if empty + dir.delete(); + } + } + + private void retryFailedReceivedMessage(final ReceiveMessageHandler handler, final boolean ignoreAttachments, final File fileEntry) { + SignalServiceEnvelope envelope; + try { + envelope = Utils.loadEnvelope(fileEntry); + if (envelope == null) { + return; + } + } catch (IOException e) { + e.printStackTrace(); + return; + } + SignalServiceContent content = null; + if (!envelope.isReceipt()) { + try { + content = decryptMessage(envelope); + } catch (Exception e) { + return; + } + List actions = handleMessage(envelope, content, ignoreAttachments); + for (HandleAction action : actions) { try { - envelope = Utils.loadEnvelope(fileEntry); - if (envelope == null) { - continue; - } - } catch (IOException e) { + action.execute(this); + } catch (Throwable e) { e.printStackTrace(); - continue; - } - SignalServiceContent content = null; - if (!envelope.isReceipt()) { - try { - content = decryptMessage(envelope); - } catch (Exception e) { - continue; - } - handleMessage(envelope, content, ignoreAttachments); - } - account.save(); - handler.handleMessage(envelope, content, null); - try { - Files.delete(fileEntry.toPath()); - } catch (IOException e) { - System.err.println("Failed to delete cached message file “" + fileEntry + "”: " + e.getMessage()); } } - // Try to delete directory if empty - dir.delete(); + } + account.save(); + handler.handleMessage(envelope, content, null); + try { + Files.delete(fileEntry.toPath()); + } catch (IOException e) { + System.err.println("Failed to delete cached message file “" + fileEntry + "”: " + e.getMessage()); } } @@ -1412,62 +1423,101 @@ public class Manager implements Signal { retryFailedReceivedMessages(handler, ignoreAttachments); final SignalServiceMessageReceiver messageReceiver = getMessageReceiver(); - try { - if (messagePipe == null) { - messagePipe = messageReceiver.createMessagePipe(); - } + Set queuedActions = null; - while (true) { - SignalServiceEnvelope envelope; - SignalServiceContent content = null; - Exception exception = null; - final long now = new Date().getTime(); - try { - envelope = messagePipe.read(timeout, unit, envelope1 -> { - // store message on disk, before acknowledging receipt to the server - try { - File cacheFile = getMessageCacheFile(envelope1.getSourceE164().get(), now, envelope1.getTimestamp()); - Utils.storeEnvelope(envelope1, cacheFile); - } catch (IOException e) { - System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage()); - } - }); - } catch (TimeoutException e) { - if (returnOnTimeout) - return; - continue; - } catch (InvalidVersionException e) { - System.err.println("Ignoring error: " + e.getMessage()); - continue; - } - if (!envelope.isReceipt()) { + if (messagePipe == null) { + messagePipe = messageReceiver.createMessagePipe(); + } + + boolean hasCaughtUpWithOldMessages = false; + + while (true) { + SignalServiceEnvelope envelope; + SignalServiceContent content = null; + Exception exception = null; + final long now = new Date().getTime(); + try { + Optional result = messagePipe.readOrEmpty(timeout, unit, envelope1 -> { + // store message on disk, before acknowledging receipt to the server try { - content = decryptMessage(envelope); - } catch (Exception e) { - exception = e; + String source = envelope1.getSourceE164().isPresent() ? envelope1.getSourceE164().get() : ""; + File cacheFile = getMessageCacheFile(source, now, envelope1.getTimestamp()); + Utils.storeEnvelope(envelope1, cacheFile); + } catch (IOException e) { + System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage()); + } + }); + if (result.isPresent()) { + envelope = result.get(); + } else { + // Received indicator that server queue is empty + hasCaughtUpWithOldMessages = true; + + if (queuedActions != null) { + for (HandleAction action : queuedActions) { + try { + action.execute(this); + } catch (Throwable e) { + e.printStackTrace(); + } + } + queuedActions.clear(); + queuedActions = null; } - handleMessage(envelope, content, ignoreAttachments); + + // Continue to wait another timeout for new messages + continue; } - account.save(); - if (!isMessageBlocked(envelope, content)) { - handler.handleMessage(envelope, content, exception); + } catch (TimeoutException e) { + if (returnOnTimeout) + return; + continue; + } catch (InvalidVersionException e) { + System.err.println("Ignoring error: " + e.getMessage()); + continue; + } + if (envelope.hasSource()) { + // Store uuid if we don't have it already + SignalServiceAddress source = envelope.getSourceAddress(); + resolveSignalServiceAddress(source); + } + if (!envelope.isReceipt()) { + try { + content = decryptMessage(envelope); + } catch (Exception e) { + exception = e; } - if (!(exception instanceof ProtocolUntrustedIdentityException)) { - File cacheFile = null; - try { - cacheFile = getMessageCacheFile(envelope.getSourceE164().get(), now, envelope.getTimestamp()); - Files.delete(cacheFile.toPath()); - // Try to delete directory if empty - new File(getMessageCachePath()).delete(); - } catch (IOException e) { - System.err.println("Failed to delete cached message file “" + cacheFile + "”: " + e.getMessage()); + List actions = handleMessage(envelope, content, ignoreAttachments); + if (hasCaughtUpWithOldMessages) { + for (HandleAction action : actions) { + try { + action.execute(this); + } catch (Throwable e) { + e.printStackTrace(); + } + } + } else { + if (queuedActions == null) { + queuedActions = new HashSet<>(); } + queuedActions.addAll(actions); } } - } finally { - if (messagePipe != null) { - messagePipe.shutdown(); - messagePipe = null; + account.save(); + if (!isMessageBlocked(envelope, content)) { + handler.handleMessage(envelope, content, exception); + } + if (!(exception instanceof org.whispersystems.libsignal.UntrustedIdentityException)) { + File cacheFile = null; + try { + String source = envelope.getSourceE164().isPresent() ? envelope.getSourceE164().get() : ""; + cacheFile = getMessageCacheFile(source, now, envelope.getTimestamp()); + Files.delete(cacheFile.toPath()); + // Try to delete directory if empty + new File(getMessageCachePath()).delete(); + } catch (IOException e) { + System.err.println("Failed to delete cached message file “" + cacheFile + "”: " + e.getMessage()); + } } } } @@ -1481,15 +1531,15 @@ public class Manager implements Signal { } else { return false; } - ContactInfo sourceContact = getContact(source.getNumber().get()); + ContactInfo sourceContact = account.getContactStore().getContact(source); if (sourceContact != null && sourceContact.blocked) { return true; } if (content != null && content.getDataMessage().isPresent()) { SignalServiceDataMessage message = content.getDataMessage().get(); - if (message.getGroupInfo().isPresent()) { - SignalServiceGroup groupInfo = message.getGroupInfo().get(); + if (message.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); GroupInfo group = getGroup(groupInfo.getGroupId()); if (groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.blocked) { return true; @@ -1499,7 +1549,8 @@ public class Manager implements Signal { return false; } - private void handleMessage(SignalServiceEnvelope envelope, SignalServiceContent content, boolean ignoreAttachments) { + private List handleMessage(SignalServiceEnvelope envelope, SignalServiceContent content, boolean ignoreAttachments) { + List actions = new ArrayList<>(); if (content != null) { SignalServiceAddress sender; if (!envelope.isUnidentifiedSender() && envelope.hasSource()) { @@ -1507,39 +1558,35 @@ public class Manager implements Signal { } else { sender = content.getSender(); } + // Store uuid if we don't have it already + resolveSignalServiceAddress(sender); + if (content.getDataMessage().isPresent()) { SignalServiceDataMessage message = content.getDataMessage().get(); - handleSignalServiceDataMessage(message, false, sender, account.getSelfAddress(), ignoreAttachments); + + if (content.isNeedsReceipt()) { + actions.add(new SendReceiptAction(sender, message.getTimestamp())); + } + + actions.addAll(handleSignalServiceDataMessage(message, false, sender, account.getSelfAddress(), ignoreAttachments)); } if (content.getSyncMessage().isPresent()) { account.setMultiDevice(true); SignalServiceSyncMessage syncMessage = content.getSyncMessage().get(); if (syncMessage.getSent().isPresent()) { SentTranscriptMessage message = syncMessage.getSent().get(); - handleSignalServiceDataMessage(message.getMessage(), true, sender, message.getDestination().orNull(), ignoreAttachments); + actions.addAll(handleSignalServiceDataMessage(message.getMessage(), true, sender, message.getDestination().orNull(), ignoreAttachments)); } if (syncMessage.getRequest().isPresent()) { RequestMessage rm = syncMessage.getRequest().get(); if (rm.isContactsRequest()) { - try { - sendContacts(); - } catch (UntrustedIdentityException | IOException e) { - e.printStackTrace(); - } + actions.add(SendSyncContactsAction.create()); } if (rm.isGroupsRequest()) { - try { - sendGroups(); - } catch (UntrustedIdentityException | IOException e) { - e.printStackTrace(); - } + actions.add(SendSyncGroupsAction.create()); } if (rm.isBlockedListRequest()) { - try { - sendBlockedList(); - } catch (UntrustedIdentityException | IOException e) { - e.printStackTrace(); - } + actions.add(SendSyncBlockedListAction.create()); } // TODO Handle rm.isConfigurationRequest(); } @@ -1558,12 +1605,15 @@ public class Manager implements Signal { if (g.getName().isPresent()) { syncGroup.name = g.getName().get(); } - syncGroup.addMembers(g.getMembers()); + syncGroup.addMembers(g.getMembers() + .stream() + .map(this::resolveSignalServiceAddress) + .collect(Collectors.toSet())); if (!g.isActive()) { - syncGroup.members.remove(account.getUsername()); + syncGroup.removeMember(account.getSelfAddress()); } else { // Add ourself to the member set as it's marked as active - syncGroup.members.add(account.getUsername()); + syncGroup.addMembers(Collections.singleton(account.getSelfAddress())); } syncGroup.blocked = g.isBlocked(); if (g.getColor().isPresent()) { @@ -1593,13 +1643,7 @@ public class Manager implements Signal { if (syncMessage.getBlockedList().isPresent()) { final BlockedListMessage blockedListMessage = syncMessage.getBlockedList().get(); for (SignalServiceAddress address : blockedListMessage.getAddresses()) { - if (address.getNumber().isPresent()) { - try { - setContactBlocked(address.getNumber().get(), true); - } catch (InvalidNumberException e) { - e.printStackTrace(); - } - } + setContactBlocked(resolveSignalServiceAddress(address), true); } for (byte[] groupId : blockedListMessage.getGroupIds()) { try { @@ -1624,10 +1668,10 @@ public class Manager implements Signal { if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) { account.setProfileKey(c.getProfileKey().get()); } - ContactInfo contact = account.getContactStore().getContact(c.getAddress().getNumber().get()); + final SignalServiceAddress address = resolveSignalServiceAddress(c.getAddress()); + ContactInfo contact = account.getContactStore().getContact(address); if (contact == null) { - contact = new ContactInfo(); - contact.number = c.getAddress().getNumber().get(); + contact = new ContactInfo(address); } if (c.getName().isPresent()) { contact.name = c.getName().get(); @@ -1640,16 +1684,10 @@ public class Manager implements Signal { } if (c.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = c.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination().getNumber().get(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + account.getSignalProtocolStore().setIdentityTrustLevel(verifiedMessage.getDestination(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); } if (c.getExpirationTimer().isPresent()) { - ThreadInfo thread = account.getThreadStore().getThread(c.getAddress().getNumber().get()); - if (thread == null) { - thread = new ThreadInfo(); - thread.id = c.getAddress().getNumber().get(); - } - thread.messageExpirationTime = c.getExpirationTimer().get(); - account.getThreadStore().updateThread(thread); + contact.messageExpirationTime = c.getExpirationTimer().get(); } contact.blocked = c.isBlocked(); contact.inboxPosition = c.getInboxPosition().orNull(); @@ -1675,21 +1713,22 @@ public class Manager implements Signal { } if (syncMessage.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = syncMessage.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination().getNumber().get(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + account.getSignalProtocolStore().setIdentityTrustLevel(resolveSignalServiceAddress(verifiedMessage.getDestination()), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); } if (syncMessage.getConfiguration().isPresent()) { // TODO } } } + return actions; } private File getContactAvatarFile(String number) { - return new File(avatarsPath, "contact-" + number); + return new File(pathConfig.getAvatarsPath(), "contact-" + number); } - private File retrieveContactAvatarAttachment(SignalServiceAttachment attachment, String number) throws IOException, InvalidMessageException { - IOUtils.createPrivateDirectories(avatarsPath); + private File retrieveContactAvatarAttachment(SignalServiceAttachment attachment, String number) throws IOException, InvalidMessageException, MissingConfigurationException { + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); if (attachment.isPointer()) { SignalServiceAttachmentPointer pointer = attachment.asPointer(); return retrieveAttachment(pointer, getContactAvatarFile(number), false); @@ -1700,11 +1739,11 @@ public class Manager implements Signal { } private File getGroupAvatarFile(byte[] groupId) { - return new File(avatarsPath, "group-" + Base64.encodeBytes(groupId).replace("/", "_")); + return new File(pathConfig.getAvatarsPath(), "group-" + Base64.encodeBytes(groupId).replace("/", "_")); } - private File retrieveGroupAvatarAttachment(SignalServiceAttachment attachment, byte[] groupId) throws IOException, InvalidMessageException { - IOUtils.createPrivateDirectories(avatarsPath); + private File retrieveGroupAvatarAttachment(SignalServiceAttachment attachment, byte[] groupId) throws IOException, InvalidMessageException, MissingConfigurationException { + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); if (attachment.isPointer()) { SignalServiceAttachmentPointer pointer = attachment.asPointer(); return retrieveAttachment(pointer, getGroupAvatarFile(groupId), false); @@ -1714,16 +1753,39 @@ public class Manager implements Signal { } } - public File getAttachmentFile(long attachmentId) { - return new File(attachmentsPath, attachmentId + ""); + private File getProfileAvatarFile(SignalServiceAddress address) { + return new File(pathConfig.getAvatarsPath(), "profile-" + address.getLegacyIdentifier()); } - private File retrieveAttachment(SignalServiceAttachmentPointer pointer) throws IOException, InvalidMessageException { - IOUtils.createPrivateDirectories(attachmentsPath); - return retrieveAttachment(pointer, getAttachmentFile(pointer.getId()), true); + private File retrieveProfileAvatar(SignalServiceAddress address, String avatarPath, ProfileKey profileKey) throws IOException { + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); + SignalServiceMessageReceiver receiver = getMessageReceiver(); + File outputFile = getProfileAvatarFile(address); + + File tmpFile = IOUtils.createTempFile(); + try (InputStream input = receiver.retrieveProfileAvatar(avatarPath, tmpFile, profileKey, ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE)) { + // Use larger buffer size to prevent AssertionError: Need: 12272 but only have: 8192 ... + IOUtils.copyStreamToFile(input, outputFile, (int) ServiceConfig.AVATAR_DOWNLOAD_FAILSAFE_MAX_SIZE); + } finally { + try { + Files.delete(tmpFile.toPath()); + } catch (IOException e) { + System.err.println("Failed to delete received avatar temp file “" + tmpFile + "”: " + e.getMessage()); + } + } + return outputFile; + } + + public File getAttachmentFile(SignalServiceAttachmentRemoteId attachmentId) { + return new File(pathConfig.getAttachmentsPath(), attachmentId.toString()); + } + + private File retrieveAttachment(SignalServiceAttachmentPointer pointer) throws IOException, InvalidMessageException, MissingConfigurationException { + IOUtils.createPrivateDirectories(pathConfig.getAttachmentsPath()); + return retrieveAttachment(pointer, getAttachmentFile(pointer.getRemoteId()), true); } - private File retrieveAttachment(SignalServiceAttachmentPointer pointer, File outputFile, boolean storePreview) throws IOException, InvalidMessageException { + private File retrieveAttachment(SignalServiceAttachmentPointer pointer, File outputFile, boolean storePreview) throws IOException, InvalidMessageException, MissingConfigurationException { if (storePreview && pointer.getPreview().isPresent()) { File previewFile = new File(outputFile + ".preview"); try (OutputStream output = new FileOutputStream(previewFile)) { @@ -1738,18 +1800,8 @@ public class Manager implements Signal { final SignalServiceMessageReceiver messageReceiver = getMessageReceiver(); File tmpFile = IOUtils.createTempFile(); - try (InputStream input = messageReceiver.retrieveAttachment(pointer, tmpFile, BaseConfig.MAX_ATTACHMENT_SIZE)) { - try (OutputStream output = new FileOutputStream(outputFile)) { - byte[] buffer = new byte[4096]; - int read; - - while ((read = input.read(buffer)) != -1) { - output.write(buffer, 0, read); - } - } catch (FileNotFoundException e) { - e.printStackTrace(); - return null; - } + try (InputStream input = messageReceiver.retrieveAttachment(pointer, tmpFile, ServiceConfig.MAX_ATTACHMENT_SIZE)) { + IOUtils.copyStreamToFile(input, outputFile); } finally { try { Files.delete(tmpFile.toPath()); @@ -1760,27 +1812,21 @@ public class Manager implements Signal { return outputFile; } - private InputStream retrieveAttachmentAsStream(SignalServiceAttachmentPointer pointer, File tmpFile) throws IOException, InvalidMessageException { + private InputStream retrieveAttachmentAsStream(SignalServiceAttachmentPointer pointer, File tmpFile) throws IOException, InvalidMessageException, MissingConfigurationException { final SignalServiceMessageReceiver messageReceiver = getMessageReceiver(); - return messageReceiver.retrieveAttachment(pointer, tmpFile, BaseConfig.MAX_ATTACHMENT_SIZE); - } - - @Override - public boolean isRemote() { - return false; + return messageReceiver.retrieveAttachment(pointer, tmpFile, ServiceConfig.MAX_ATTACHMENT_SIZE); } - private void sendGroups() throws IOException, UntrustedIdentityException { + void sendGroups() throws IOException, UntrustedIdentityException { File groupsFile = IOUtils.createTempFile(); try { try (OutputStream fos = new FileOutputStream(groupsFile)) { DeviceGroupsOutputStream out = new DeviceGroupsOutputStream(fos); for (GroupInfo record : account.getGroupStore().getGroups()) { - ThreadInfo info = account.getThreadStore().getThread(Base64.encodeBytes(record.groupId)); out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name), new ArrayList<>(record.getMembers()), createGroupAvatarAttachment(record.groupId), - record.members.contains(account.getUsername()), Optional.fromNullable(info != null ? info.messageExpirationTime : null), + record.isMember(account.getSelfAddress()), Optional.of(record.messageExpirationTime), Optional.fromNullable(record.color), record.blocked, Optional.fromNullable(record.inboxPosition), record.archived)); } } @@ -1813,17 +1859,9 @@ public class Manager implements Signal { DeviceContactsOutputStream out = new DeviceContactsOutputStream(fos); for (ContactInfo record : account.getContactStore().getContacts()) { VerifiedMessage verifiedMessage = null; - ThreadInfo info = account.getThreadStore().getThread(record.number); - if (getIdentities().containsKey(record.number)) { - JsonIdentityKeyStore.Identity currentIdentity = null; - for (JsonIdentityKeyStore.Identity id : getIdentities().get(record.number)) { - if (currentIdentity == null || id.getDateAdded().after(currentIdentity.getDateAdded())) { - currentIdentity = id; - } - } - if (currentIdentity != null) { - verifiedMessage = new VerifiedMessage(record.getAddress(), currentIdentity.getIdentityKey(), currentIdentity.getTrustLevel().toVerifiedState(), currentIdentity.getDateAdded().getTime()); - } + JsonIdentityKeyStore.Identity currentIdentity = account.getSignalProtocolStore().getIdentity(record.getAddress()); + if (currentIdentity != null) { + verifiedMessage = new VerifiedMessage(record.getAddress(), currentIdentity.getIdentityKey(), currentIdentity.getTrustLevel().toVerifiedState(), currentIdentity.getDateAdded().getTime()); } ProfileKey profileKey = null; @@ -1834,7 +1872,7 @@ public class Manager implements Signal { out.write(new DeviceContact(record.getAddress(), Optional.fromNullable(record.name), createContactAvatarAttachment(record.number), Optional.fromNullable(record.color), Optional.fromNullable(verifiedMessage), Optional.fromNullable(profileKey), record.blocked, - Optional.fromNullable(info != null ? info.messageExpirationTime : null), + Optional.of(record.messageExpirationTime), Optional.fromNullable(record.inboxPosition), record.archived)); } @@ -1868,7 +1906,7 @@ public class Manager implements Signal { } } - private void sendBlockedList() throws IOException, UntrustedIdentityException { + void sendBlockedList() throws IOException, UntrustedIdentityException { List addresses = new ArrayList<>(); for (ContactInfo record : account.getContactStore().getContacts()) { if (record.blocked) { @@ -1894,20 +1932,19 @@ public class Manager implements Signal { } public ContactInfo getContact(String number) { - return account.getContactStore().getContact(number); + return account.getContactStore().getContact(Util.getSignalServiceAddressFromIdentifier(number)); } public GroupInfo getGroup(byte[] groupId) { return account.getGroupStore().getGroup(groupId); } - public Map> getIdentities() { + public List getIdentities() { return account.getSignalProtocolStore().getIdentities(); } - public Pair> getIdentities(String number) throws InvalidNumberException { - String canonicalizedNumber = Utils.canonicalizeNumber(number, account.getUsername()); - return new Pair<>(canonicalizedNumber, account.getSignalProtocolStore().getIdentities(canonicalizedNumber)); + public List getIdentities(String number) throws InvalidNumberException { + return account.getSignalProtocolStore().getIdentities(canonicalizeAndResolveSignalServiceAddress(number)); } /** @@ -1916,8 +1953,9 @@ public class Manager implements Signal { * @param name username of the identity * @param fingerprint Fingerprint */ - public boolean trustIdentityVerified(String name, byte[] fingerprint) { - List ids = account.getSignalProtocolStore().getIdentities(name); + public boolean trustIdentityVerified(String name, byte[] fingerprint) throws InvalidNumberException { + SignalServiceAddress address = canonicalizeAndResolveSignalServiceAddress(name); + List ids = account.getSignalProtocolStore().getIdentities(address); if (ids == null) { return false; } @@ -1926,9 +1964,9 @@ public class Manager implements Signal { continue; } - account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + account.getSignalProtocolStore().setIdentityTrustLevel(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); try { - sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1944,19 +1982,20 @@ public class Manager implements Signal { * @param name username of the identity * @param safetyNumber Safety number */ - public boolean trustIdentityVerifiedSafetyNumber(String name, String safetyNumber) { - List ids = account.getSignalProtocolStore().getIdentities(name); + public boolean trustIdentityVerifiedSafetyNumber(String name, String safetyNumber) throws InvalidNumberException { + SignalServiceAddress address = canonicalizeAndResolveSignalServiceAddress(name); + List ids = account.getSignalProtocolStore().getIdentities(address); if (ids == null) { return false; } for (JsonIdentityKeyStore.Identity id : ids) { - if (!safetyNumber.equals(computeSafetyNumber(name, id.getIdentityKey()))) { + if (!safetyNumber.equals(computeSafetyNumber(address, id.getIdentityKey()))) { continue; } - account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + account.getSignalProtocolStore().setIdentityTrustLevel(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); try { - sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1972,15 +2011,16 @@ public class Manager implements Signal { * @param name username of the identity */ public boolean trustIdentityAllKeys(String name) { - List ids = account.getSignalProtocolStore().getIdentities(name); + SignalServiceAddress address = resolveSignalServiceAddress(name); + List ids = account.getSignalProtocolStore().getIdentities(address); if (ids == null) { return false; } for (JsonIdentityKeyStore.Identity id : ids) { if (id.getTrustLevel() == TrustLevel.UNTRUSTED) { - account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); + account.getSignalProtocolStore().setIdentityTrustLevel(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); try { - sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1990,8 +2030,46 @@ public class Manager implements Signal { return true; } - public String computeSafetyNumber(String theirUsername, IdentityKey theirIdentityKey) { - return Utils.computeSafetyNumber(account.getUsername(), getIdentity(), theirUsername, theirIdentityKey); + public String computeSafetyNumber(SignalServiceAddress theirAddress, IdentityKey theirIdentityKey) { + return Utils.computeSafetyNumber(account.getSelfAddress(), getIdentityKeyPair().getPublicKey(), theirAddress, theirIdentityKey); + } + + void saveAccount() { + account.save(); + } + + public SignalServiceAddress canonicalizeAndResolveSignalServiceAddress(String identifier) throws InvalidNumberException { + String canonicalizedNumber = UuidUtil.isUuid(identifier) ? identifier : Util.canonicalizeNumber(identifier, account.getUsername()); + return resolveSignalServiceAddress(canonicalizedNumber); + } + + public SignalServiceAddress resolveSignalServiceAddress(String identifier) { + SignalServiceAddress address = Util.getSignalServiceAddressFromIdentifier(identifier); + + return resolveSignalServiceAddress(address); + } + + public SignalServiceAddress resolveSignalServiceAddress(SignalServiceAddress address) { + if (address.matches(account.getSelfAddress())) { + return account.getSelfAddress(); + } + + return account.getRecipientStore().resolveServiceAddress(address); + } + + @Override + public void close() throws IOException { + if (messagePipe != null) { + messagePipe.shutdown(); + messagePipe = null; + } + + if (unidentifiedMessagePipe != null) { + unidentifiedMessagePipe.shutdown(); + unidentifiedMessagePipe = null; + } + + account.close(); } public interface ReceiveMessageHandler {