X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/e809792467f50ed482fa4a2fd6e5e1577d306e6f..4f2261e86f493a9c8954c02c52ddaa9a46490d20:/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 f18cb219..c556ed41 100644 --- a/src/main/java/org/asamk/signal/manager/Manager.java +++ b/src/main/java/org/asamk/signal/manager/Manager.java @@ -1,5 +1,5 @@ /* - Copyright (C) 2015-2018 AsamK + Copyright (C) 2015-2020 AsamK and contributors This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,18 +16,48 @@ */ package org.asamk.signal.manager; -import org.asamk.Signal; -import org.asamk.signal.*; +import com.fasterxml.jackson.databind.ObjectMapper; + +import org.asamk.signal.manager.helper.GroupHelper; +import org.asamk.signal.manager.helper.ProfileHelper; +import org.asamk.signal.manager.helper.UnidentifiedAccessHelper; 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.groups.GroupInfoV1; +import org.asamk.signal.storage.groups.GroupInfoV2; +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.storage.stickers.Sticker; import org.asamk.signal.util.IOUtils; import org.asamk.signal.util.Util; -import org.signal.libsignal.metadata.*; -import org.whispersystems.libsignal.*; +import org.signal.libsignal.metadata.InvalidMetadataMessageException; +import org.signal.libsignal.metadata.InvalidMetadataVersionException; +import org.signal.libsignal.metadata.ProtocolDuplicateMessageException; +import org.signal.libsignal.metadata.ProtocolInvalidKeyException; +import org.signal.libsignal.metadata.ProtocolInvalidKeyIdException; +import org.signal.libsignal.metadata.ProtocolInvalidMessageException; +import org.signal.libsignal.metadata.ProtocolInvalidVersionException; +import org.signal.libsignal.metadata.ProtocolLegacyMessageException; +import org.signal.libsignal.metadata.ProtocolNoSessionException; +import org.signal.libsignal.metadata.ProtocolUntrustedIdentityException; +import org.signal.libsignal.metadata.SelfSendException; +import org.signal.storageservice.protos.groups.local.DecryptedGroup; +import org.signal.storageservice.protos.groups.local.DecryptedMember; +import org.signal.zkgroup.InvalidInputException; +import org.signal.zkgroup.VerificationFailedException; +import org.signal.zkgroup.auth.AuthCredentialResponse; +import org.signal.zkgroup.groups.GroupMasterKey; +import org.signal.zkgroup.groups.GroupSecretParams; +import org.signal.zkgroup.profiles.ClientZkProfileOperations; +import org.signal.zkgroup.profiles.ProfileKey; +import org.signal.zkgroup.profiles.ProfileKeyCredential; +import org.whispersystems.libsignal.IdentityKey; +import org.whispersystems.libsignal.IdentityKeyPair; +import org.whispersystems.libsignal.InvalidKeyException; +import org.whispersystems.libsignal.InvalidMessageException; +import org.whispersystems.libsignal.InvalidVersionException; import org.whispersystems.libsignal.ecc.Curve; import org.whispersystems.libsignal.ecc.ECKeyPair; import org.whispersystems.libsignal.ecc.ECPublicKey; @@ -35,67 +65,179 @@ import org.whispersystems.libsignal.state.PreKeyRecord; import org.whispersystems.libsignal.state.SignedPreKeyRecord; import org.whispersystems.libsignal.util.KeyHelper; import org.whispersystems.libsignal.util.Medium; +import org.whispersystems.libsignal.util.Pair; import org.whispersystems.libsignal.util.guava.Optional; import org.whispersystems.signalservice.api.SignalServiceAccountManager; import org.whispersystems.signalservice.api.SignalServiceMessagePipe; import org.whispersystems.signalservice.api.SignalServiceMessageReceiver; import org.whispersystems.signalservice.api.SignalServiceMessageSender; +import org.whispersystems.signalservice.api.crypto.InvalidCiphertextException; +import org.whispersystems.signalservice.api.crypto.ProfileCipher; 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.messages.*; -import org.whispersystems.signalservice.api.messages.multidevice.*; +import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations; +import org.whispersystems.signalservice.api.groupsv2.GroupsV2Api; +import org.whispersystems.signalservice.api.groupsv2.GroupsV2AuthorizationString; +import org.whispersystems.signalservice.api.groupsv2.GroupsV2Operations; +import org.whispersystems.signalservice.api.groupsv2.InvalidGroupStateException; +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.SignalServiceGroupV2; +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; +import org.whispersystems.signalservice.api.messages.multidevice.ContactsMessage; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceContact; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsInputStream; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceContactsOutputStream; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroup; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsInputStream; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceGroupsOutputStream; +import org.whispersystems.signalservice.api.messages.multidevice.DeviceInfo; +import org.whispersystems.signalservice.api.messages.multidevice.RequestMessage; +import org.whispersystems.signalservice.api.messages.multidevice.SentTranscriptMessage; +import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage; +import org.whispersystems.signalservice.api.messages.multidevice.StickerPackOperationMessage; +import org.whispersystems.signalservice.api.messages.multidevice.VerifiedMessage; +import org.whispersystems.signalservice.api.profiles.ProfileAndCredential; +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.NetworkFailureException; -import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException; +import org.whispersystems.signalservice.api.push.exceptions.MissingConfigurationException; 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.util.Base64; - -import java.io.*; +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; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; import java.net.URI; +import java.net.URISyntaxException; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; import java.nio.file.StandardCopyOption; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; +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; + +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 SignalAccount account; - private String username; + private final SignalServiceConfiguration serviceConfiguration; + private final String userAgent; + private final boolean discoverableByPhoneNumber = true; + private final boolean unrestrictedUnidentifiedAccess = false; + + private final SignalAccount account; + private final PathConfig pathConfig; private SignalServiceAccountManager accountManager; + private GroupsV2Api groupsV2Api; + private final GroupsV2Operations groupsV2Operations; + + private SignalServiceMessageReceiver messageReceiver = null; private SignalServiceMessagePipe messagePipe = null; private SignalServiceMessagePipe unidentifiedMessagePipe = null; - 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"; - + private final UnidentifiedAccessHelper unidentifiedAccessHelper; + private final ProfileHelper profileHelper; + private final GroupHelper groupHelper; + + public Manager( + SignalAccount account, + PathConfig pathConfig, + SignalServiceConfiguration serviceConfiguration, + String userAgent + ) { + this.account = account; + this.pathConfig = pathConfig; + this.serviceConfiguration = serviceConfiguration; + this.userAgent = userAgent; + this.groupsV2Operations = capabilities.isGv2() ? new GroupsV2Operations(ClientZkOperations.create( + serviceConfiguration)) : null; + this.accountManager = createSignalServiceAccountManager(); + this.groupsV2Api = accountManager.getGroupsV2Api(); + + this.account.setResolver(this::resolveSignalServiceAddress); + + this.unidentifiedAccessHelper = new UnidentifiedAccessHelper(account::getProfileKey, + account.getProfileStore()::getProfileKey, + this::getRecipientProfile, + this::getSenderCertificate); + this.profileHelper = new ProfileHelper(account.getProfileStore()::getProfileKey, + unidentifiedAccessHelper::getAccessFor, + unidentified -> unidentified ? getOrCreateUnidentifiedMessagePipe() : getOrCreateMessagePipe(), + this::getOrCreateMessageReceiver); + this.groupHelper = new GroupHelper(this::getRecipientProfileKeyCredential, + this::getRecipientProfile, + account::getSelfAddress, + groupsV2Operations); } public String getUsername() { - return username; + return account.getUsername(); + } + + public SignalServiceAddress getSelfAddress() { + return account.getSelfAddress(); } - private IdentityKey getIdentity() { - return account.getSignalProtocolStore().getIdentityKeyPair().getPublicKey(); + private SignalServiceAccountManager createSignalServiceAccountManager() { + 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() { @@ -103,10 +245,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("/", "_"); } @@ -116,133 +262,121 @@ 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 = new SignalServiceAccountManager(BaseConfig.serviceConfiguration, username, account.getPassword(), account.getDeviceId(), BaseConfig.USER_AGENT, timer); - 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?"); + 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() { - // Copy group avatars that were previously stored in the attachments folder - // to the new avatar folder - if (JsonGroupStore.groupsWithLegacyAvatarId.size() > 0) { - for (GroupInfo g : JsonGroupStore.groupsWithLegacyAvatarId) { - File avatarFile = getGroupAvatarFile(g.groupId); - File attachmentFile = getAttachmentFile(g.getAvatarId()); - if (!avatarFile.exists() && attachmentFile.exists()) { - try { - IOUtils.createPrivateDirectories(avatarsPath); - Files.copy(attachmentFile.toPath(), avatarFile.toPath(), StandardCopyOption.REPLACE_EXISTING); - } catch (Exception e) { - // Ignore - } - } - } - JsonGroupStore.groupsWithLegacyAvatarId.clear(); - account.save(); - } - if (account.getProfileKey() == null) { + if (account.getProfileKey() == null && isRegistered()) { // Old config file, creating new profile key account.setProfileKey(KeyUtils.createProfileKey()); account.save(); } + // Store profile keys only in profile store + for (ContactInfo contact : account.getContactStore().getContacts()) { + String profileKeyString = contact.profileKey; + if (profileKeyString == null) { + continue; + } + final ProfileKey profileKey; + try { + profileKey = new ProfileKey(Base64.decode(profileKeyString)); + } catch (InvalidInputException | IOException e) { + continue; + } + contact.profileKey = null; + account.getProfileStore().storeProfileKey(contact.getAddress(), profileKey); + } } - private void createNewIdentity() throws IOException { - IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair(); - int registrationId = KeyHelper.generateRegistrationId(false); - if (username == null) { - account = SignalAccount.createTemporaryAccount(identityKey, registrationId); - } else { - byte[] 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(); + } + updateAccountAttributes(); } } public boolean isRegistered() { - return account != null && account.isRegistered(); + return account.isRegistered(); } - public void register(boolean voiceVerification) throws IOException { - if (account == null) { - createNewIdentity(); - } + public void register(boolean voiceVerification, String captcha) throws IOException { account.setPassword(KeyUtils.createPassword()); - accountManager = new SignalServiceAccountManager(BaseConfig.serviceConfiguration, account.getUsername(), account.getPassword(), BaseConfig.USER_AGENT, timer); - if (voiceVerification) - accountManager.requestVoiceVerificationCode(); - else - accountManager.requestSmsVerificationCode(); + // Resetting UUID, because registering doesn't work otherwise + account.setUuid(null); + accountManager = createSignalServiceAccountManager(); + this.groupsV2Api = accountManager.getGroupsV2Api(); + + if (voiceVerification) { + accountManager.requestVoiceVerificationCode(Locale.getDefault(), + Optional.fromNullable(captcha), + Optional.absent()); + } else { + accountManager.requestSmsVerificationCode(false, Optional.fromNullable(captcha), Optional.absent()); + } account.setRegistered(false); account.save(); } public void updateAccountAttributes() throws IOException { - accountManager.setAccountAttributes(account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, account.getRegistrationLockPin(), getSelfUnidentifiedAccessKey(), false); + accountManager.setAccountAttributes(account.getSignalingKey(), + account.getSignalProtocolStore().getLocalRegistrationId(), + true, + account.getRegistrationLockPin(), + account.getRegistrationLock(), + unidentifiedAccessHelper.getSelfUnidentifiedAccessKey(), + unrestrictedUnidentifiedAccess, + capabilities, + discoverableByPhoneNumber); + } + + 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 { // When setting an empty GCM id, the Signal-Server also sets the fetchesMessages property to false. // If this is the master device, other users can't send messages to this number anymore. // If this is a linked device, other users can still send messages, but this device doesn't receive them anymore. - accountManager.setGcmId(Optional.absent()); - } - - public String getDeviceLinkUri() throws TimeoutException, IOException { - if (account == null) { - createNewIdentity(); - } - account.setPassword(KeyUtils.createPassword()); - accountManager = new SignalServiceAccountManager(BaseConfig.serviceConfiguration, username, account.getPassword(), BaseConfig.USER_AGENT, timer); - 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[] profileKey = ret.getProfileKey(); - if (profileKey == null) { - profileKey = KeyUtils.createProfileKey(); - } - account = SignalAccount.createLinkedAccount(dataPath, username, account.getPassword(), ret.getDeviceId(), ret.getIdentity(), account.getSignalProtocolStore().getLocalRegistrationId(), account.getSignalingKey(), profileKey); - - refreshPreKeys(); - - requestSyncGroups(); - requestSyncContacts(); - requestSyncBlocked(); - requestSyncConfiguration(); + accountManager.setGcmId(Optional.absent()); + account.setRegistered(false); account.save(); } @@ -267,19 +401,23 @@ 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()), verificationCode); + accountManager.addDevice(deviceIdentifier, + deviceKey, + identityKeyPair, + Optional.of(account.getProfileKey().serialize()), + verificationCode); account.setMultiDevice(true); account.save(); } 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); @@ -296,8 +434,12 @@ public class Manager implements Signal { private SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair) { try { ECKeyPair keyPair = Curve.generateKeyPair(); - byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize()); - SignedPreKeyRecord record = new SignedPreKeyRecord(account.getNextSignedPreKeyId(), System.currentTimeMillis(), keyPair, signature); + byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), + keyPair.getPublicKey().serialize()); + SignedPreKeyRecord record = new SignedPreKeyRecord(account.getNextSignedPreKeyId(), + System.currentTimeMillis(), + keyPair, + signature); account.addSignedPreKey(record); account.save(); @@ -312,32 +454,216 @@ 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, getSelfUnidentifiedAccessKey(), false); - + VerifyAccountResponse response = accountManager.verifyAccountWithCode(verificationCode, + account.getSignalingKey(), + account.getSignalProtocolStore().getLocalRegistrationId(), + true, + pin, + null, + unidentifiedAccessHelper.getSelfUnidentifiedAccessKey(), + unrestrictedUnidentifiedAccess, + 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(); } public void setRegistrationLockPin(Optional pin) throws IOException { - accountManager.setPin(pin); if (pin.isPresent()) { account.setRegistrationLockPin(pin.get()); + throw new RuntimeException("Not implemented anymore, will be replaced with KBS"); } else { account.setRegistrationLockPin(null); + 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 createMessageReceiver() { + final ClientZkProfileOperations clientZkProfileOperations = capabilities.isGv2() ? ClientZkOperations.create( + serviceConfiguration).getProfileOperations() : null; + return new SignalServiceMessageReceiver(serviceConfiguration, + account.getUuid(), + account.getUsername(), + account.getPassword(), + account.getDeviceId(), + account.getSignalingKey(), + userAgent, + null, + timer, + clientZkProfileOperations); + } + + private SignalServiceMessageReceiver getOrCreateMessageReceiver() { + if (messageReceiver == null) { + messageReceiver = createMessageReceiver(); + } + return messageReceiver; + } + + private SignalServiceMessagePipe getOrCreateMessagePipe() { + if (messagePipe == null) { + messagePipe = getOrCreateMessageReceiver().createMessagePipe(); + } + return messagePipe; + } + + private SignalServiceMessagePipe getOrCreateUnidentifiedMessagePipe() { + if (unidentifiedMessagePipe == null) { + unidentifiedMessagePipe = getOrCreateMessageReceiver().createUnidentifiedMessagePipe(); + } + return unidentifiedMessagePipe; + } + + private SignalServiceMessageSender createMessageSender() { + final ClientZkProfileOperations clientZkProfileOperations = capabilities.isGv2() ? ClientZkOperations.create( + serviceConfiguration).getProfileOperations() : null; + final ExecutorService executor = null; + return new SignalServiceMessageSender(serviceConfiguration, + account.getUuid(), + account.getUsername(), + account.getPassword(), + account.getDeviceId(), + account.getSignalProtocolStore(), + userAgent, + account.isMultiDevice(), + Optional.fromNullable(messagePipe), + Optional.fromNullable(unidentifiedMessagePipe), + Optional.absent(), + clientZkProfileOperations, + executor, + ServiceConfig.MAX_ENVELOPE_SIZE); + } + + private SignalServiceProfile getEncryptedRecipientProfile(SignalServiceAddress address) throws IOException { + return profileHelper.retrieveProfileSync(address, SignalServiceProfile.RequestType.PROFILE).getProfile(); + } + + private SignalProfile getRecipientProfile( + SignalServiceAddress address + ) { + SignalProfileEntry profileEntry = account.getProfileStore().getProfileEntry(address); + if (profileEntry == null) { + return null; + } + long now = new Date().getTime(); + // Profiles are cache for 24h before retrieving them again + if (!profileEntry.isRequestPending() && ( + profileEntry.getProfile() == null || now - profileEntry.getLastUpdateTimestamp() > 24 * 60 * 60 * 1000 + )) { + ProfileKey profileKey = profileEntry.getProfileKey(); + profileEntry.setRequestPending(true); + SignalProfile profile; + try { + profile = retrieveRecipientProfile(address, profileKey); + } catch (IOException e) { + System.err.println("Failed to retrieve profile, ignoring: " + e.getMessage()); + profileEntry.setRequestPending(false); + return null; + } + profileEntry.setRequestPending(false); + account.getProfileStore() + .updateProfile(address, profileKey, now, profile, profileEntry.getProfileKeyCredential()); + return profile; + } + return profileEntry.getProfile(); + } + + private ProfileKeyCredential getRecipientProfileKeyCredential(SignalServiceAddress address) { + SignalProfileEntry profileEntry = account.getProfileStore().getProfileEntry(address); + if (profileEntry == null) { + return null; + } + if (profileEntry.getProfileKeyCredential() == null) { + ProfileAndCredential profileAndCredential; + try { + profileAndCredential = profileHelper.retrieveProfileSync(address, + SignalServiceProfile.RequestType.PROFILE_AND_CREDENTIAL); + } catch (IOException e) { + System.err.println("Failed to retrieve profile key credential, ignoring: " + e.getMessage()); + return null; + } + + long now = new Date().getTime(); + final ProfileKeyCredential profileKeyCredential = profileAndCredential.getProfileKeyCredential().orNull(); + final SignalProfile profile = decryptProfile(address, + profileEntry.getProfileKey(), + profileAndCredential.getProfile()); + account.getProfileStore() + .updateProfile(address, profileEntry.getProfileKey(), now, profile, profileKeyCredential); + return profileKeyCredential; + } + return profileEntry.getProfileKeyCredential(); + } + + private SignalProfile retrieveRecipientProfile( + SignalServiceAddress address, ProfileKey profileKey + ) throws IOException { + final SignalServiceProfile encryptedProfile = getEncryptedRecipientProfile(address); + + return decryptProfile(address, profileKey, encryptedProfile); + } + + private SignalProfile decryptProfile( + final SignalServiceAddress address, final ProfileKey profileKey, final SignalServiceProfile encryptedProfile + ) { + 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 { + String name; + try { + name = encryptedProfile.getName() == null + ? null + : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName()))); + } catch (IOException e) { + name = null; + } + String unidentifiedAccess; + try { + unidentifiedAccess = encryptedProfile.getUnidentifiedAccess() == null + || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess())) + ? null + : encryptedProfile.getUnidentifiedAccess(); + } catch (IOException e) { + unidentifiedAccess = null; + } + return new SignalProfile(encryptedProfile.getIdentityKey(), + name, + avatarFile, + unidentifiedAccess, + encryptedProfile.isUnrestrictedUnidentifiedAccess(), + encryptedProfile.getCapabilities()); + } catch (InvalidCiphertextException e) { + return null; + } } private Optional createGroupAvatarAttachment(byte[] groupId) throws IOException { @@ -363,142 +689,201 @@ public class Manager implements Signal { if (g == null) { throw new GroupNotFoundException(groupId); } - for (String member : g.members) { - if (member.equals(this.username)) { - return g; - } + if (!g.isMember(account.getSelfAddress())) { + throw new NotAGroupMemberException(groupId, g.getTitle()); } - throw new NotAGroupMemberException(groupId, g.name); + return g; } public List getGroups() { return account.getGroupStore().getGroups(); } - @Override - public void sendGroupMessage(String messageText, List attachments, - byte[] groupId) - throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException { - final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); + public Pair> sendGroupMessage( + SignalServiceDataMessage.Builder messageBuilder, byte[] groupId + ) throws IOException, GroupNotFoundException, NotAGroupMemberException { + final GroupInfo g = getGroupForSending(groupId); + + GroupHelper.setGroupContext(messageBuilder, g); + messageBuilder.withExpiration(g.getMessageExpirationTime()); + + return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress())); + } + + public Pair> sendGroupMessage( + String messageText, List attachments, byte[] groupId + ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException { + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withBody(messageText); if (attachments != null) { messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments)); } - if (groupId != null) { - SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER) - .withId(groupId) - .build(); - messageBuilder.asGroupMessage(group); - } - ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(groupId)); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); - } - final GroupInfo g = getGroupForSending(groupId); + return sendGroupMessage(messageBuilder, groupId); + } - // Don't send group message to ourself - final List membersSend = new ArrayList<>(g.members); - membersSend.remove(this.username); - sendMessageLegacy(messageBuilder, membersSend); + public Pair> sendGroupMessageReaction( + String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, byte[] groupId + ) throws IOException, InvalidNumberException, NotAGroupMemberException, GroupNotFoundException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, + remove, + canonicalizeAndResolveSignalServiceAddress(targetAuthor), + targetSentTimestamp); + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withReaction(reaction); + + return sendGroupMessage(messageBuilder, groupId); } - public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions { - SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT) - .withId(groupId) - .build(); + public Pair> sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, NotAGroupMemberException { + SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT).withId(groupId).build(); - SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() - .asGroupMessage(group); + SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().asGroupMessage(group); final GroupInfo g = getGroupForSending(groupId); - g.members.remove(this.username); - account.getGroupStore().updateGroup(g); + if (g instanceof GroupInfoV1) { + GroupInfoV1 groupInfoV1 = (GroupInfoV1) g; + groupInfoV1.removeMember(account.getSelfAddress()); + account.getGroupStore().updateGroup(groupInfoV1); + } else { + throw new RuntimeException("TODO Not implemented!"); + } + + return sendMessage(messageBuilder, g.getMembersWithout(account.getSelfAddress())); + } - sendMessageLegacy(messageBuilder, g.members); + private GroupInfoV2 createGroupV2( + String name, Collection members, InputStream avatar + ) throws IOException { + byte[] avatarBytes = avatar == null ? null : IOUtils.readFully(avatar); + final GroupsV2Operations.NewGroup newGroup = groupHelper.createGroupV2(name, members, avatarBytes); + final GroupSecretParams groupSecretParams = newGroup.getGroupSecretParams(); + + final GroupsV2AuthorizationString groupAuthForToday; + final DecryptedGroup decryptedGroup; + try { + groupAuthForToday = getGroupAuthForToday(groupSecretParams); + groupsV2Api.putNewGroup(newGroup, groupAuthForToday); + decryptedGroup = groupsV2Api.getGroup(groupSecretParams, groupAuthForToday); + } catch (IOException | VerificationFailedException | InvalidGroupStateException e) { + System.err.println("Failed to create V2 group: " + e.getMessage()); + return null; + } + if (decryptedGroup == null) { + System.err.println("Failed to create V2 group!"); + return null; + } + + final byte[] groupId = groupSecretParams.getPublicParams().getGroupIdentifier().serialize(); + final GroupMasterKey masterKey = groupSecretParams.getMasterKey(); + GroupInfoV2 g = new GroupInfoV2(groupId, masterKey); + g.setGroup(decryptedGroup); + + return g; } - private byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException { + private Pair> sendUpdateGroupMessage( + byte[] groupId, String name, Collection members, String avatarFile + ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException { GroupInfo g; + SignalServiceDataMessage.Builder messageBuilder; if (groupId == null) { // Create new group - g = new GroupInfo(KeyUtils.createGroupId()); - g.members.add(username); + InputStream avatar = avatarFile == null ? null : new FileInputStream(avatarFile); + GroupInfoV2 gv2 = createGroupV2(name, members, avatar); + if (gv2 == null) { + GroupInfoV1 gv1 = new GroupInfoV1(KeyUtils.createGroupId()); + gv1.addMembers(Collections.singleton(account.getSelfAddress())); + updateGroupV1(gv1, name, members, avatarFile); + messageBuilder = getGroupUpdateMessageBuilder(gv1); + g = gv1; + } else { + messageBuilder = getGroupUpdateMessageBuilder(gv2); + g = gv2; + } } else { - g = getGroupForSending(groupId); + GroupInfo group = getGroupForSending(groupId); + if (!(group instanceof GroupInfoV1)) { + throw new RuntimeException("TODO Not implemented!"); + } + GroupInfoV1 gv1 = (GroupInfoV1) group; + updateGroupV1(gv1, name, members, avatarFile); + messageBuilder = getGroupUpdateMessageBuilder(gv1); + g = gv1; } + account.getGroupStore().updateGroup(g); + + final Pair> result = sendMessage(messageBuilder, + g.getMembersWithout(account.getSelfAddress())); + return new Pair<>(g.groupId, result.second()); + } + + private void updateGroupV1( + final GroupInfoV1 g, + final String name, + final Collection members, + final String avatarFile + ) throws IOException { if (name != null) { g.name = name; } if (members != null) { - Set newMembers = new HashSet<>(); - for (String member : members) { - try { - member = Utils.canonicalizeNumber(member, username); - } catch (InvalidNumberException e) { - System.err.println("Failed to add member \"" + member + "\" to group: " + e.getMessage()); - System.err.println("Aborting…"); - System.exit(1); - } - 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); } - - account.getGroupStore().updateGroup(g); - - SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g); - - // Don't send group message to ourself - final List membersSend = new ArrayList<>(g.members); - membersSend.remove(this.username); - sendMessageLegacy(messageBuilder, membersSend); - return g.groupId; } - private void sendUpdateGroupMessage(byte[] groupId, String recipient) throws IOException, EncapsulatedExceptions { - if (groupId == null) { - return; + Pair> sendUpdateGroupMessage( + byte[] groupId, SignalServiceAddress recipient + ) throws IOException, NotAGroupMemberException, GroupNotFoundException, AttachmentInvalidException { + GroupInfoV1 g; + GroupInfo group = getGroupForSending(groupId); + if (!(group instanceof GroupInfoV1)) { + throw new RuntimeException("TODO Not implemented!"); } - GroupInfo g = getGroupForSending(groupId); + g = (GroupInfoV1) group; - if (!g.members.contains(recipient)) { - return; + if (!g.isMember(recipient)) { + throw new NotAGroupMemberException(groupId, g.name); } SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g); // Send group message only to the recipient who requested it - final List membersSend = new ArrayList<>(); - membersSend.add(recipient); - sendMessageLegacy(messageBuilder, membersSend); + return sendMessage(messageBuilder, Collections.singleton(recipient)); } - private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) { + private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV1 g) throws AttachmentInvalidException { SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE) .withId(g.groupId) .withName(g.name) - .withMembers(new ArrayList<>(g.members)); + .withMembers(new ArrayList<>(g.getMembers())); File aFile = getGroupAvatarFile(g.groupId); if (aFile.exists()) { @@ -510,14 +895,23 @@ public class Manager implements Signal { } return SignalServiceDataMessage.newBuilder() - .asGroupMessage(group.build()); + .asGroupMessage(group.build()) + .withExpiration(g.getMessageExpirationTime()); } - private void sendGroupInfoRequest(byte[] groupId, String recipient) throws IOException, EncapsulatedExceptions { - if (groupId == null) { - return; - } + private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfoV2 g) { + SignalServiceGroupV2.Builder group = SignalServiceGroupV2.newBuilder(g.getMasterKey()) + .withRevision(g.getGroup().getRevision()) +// .withSignedGroupChange() // TODO + ; + return SignalServiceDataMessage.newBuilder() + .asGroupMessage(group.build()) + .withExpiration(g.getMessageExpirationTime()); + } + Pair> sendGroupInfoRequest( + byte[] groupId, SignalServiceAddress recipient + ) throws IOException { SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO) .withId(groupId); @@ -525,41 +919,74 @@ public class Manager implements Signal { .asGroupMessage(group.build()); // Send group info request message to the recipient who sent us a message with this groupId - final List membersSend = new ArrayList<>(); - membersSend.add(recipient); - sendMessageLegacy(messageBuilder, membersSend); + return sendMessage(messageBuilder, Collections.singleton(recipient)); } - @Override - public void sendMessage(String message, List attachments, String recipient) - throws EncapsulatedExceptions, AttachmentInvalidException, IOException { - 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()); + + createMessageSender().sendReceipt(remoteAddress, + unidentifiedAccessHelper.getAccessFor(remoteAddress), + receiptMessage); } - @Override - public void sendMessage(String messageText, List attachments, - List recipients) - throws IOException, EncapsulatedExceptions, AttachmentInvalidException { - final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); + public Pair> sendMessage( + String messageText, List attachments, List recipients + ) throws IOException, AttachmentInvalidException, InvalidNumberException { + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withBody(messageText); if (attachments != null) { - messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments)); + List attachmentStreams = Utils.getSignalServiceAttachments(attachments); + + // Upload attachments here, so we only upload once even for multiple recipients + SignalServiceMessageSender messageSender = createMessageSender(); + List attachmentPointers = new ArrayList<>(attachmentStreams.size()); + for (SignalServiceAttachment attachment : attachmentStreams) { + if (attachment.isStream()) { + attachmentPointers.add(messageSender.uploadAttachment(attachment.asStream())); + } else if (attachment.isPointer()) { + attachmentPointers.add(attachment.asPointer()); + } + } + + messageBuilder.withAttachments(attachmentPointers); } - sendMessageLegacy(messageBuilder, recipients); + return sendMessage(messageBuilder, getSignalServiceAddresses(recipients)); } - @Override - public void sendEndSessionMessage(List recipients) throws IOException, EncapsulatedExceptions { - SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() - .asEndSessionMessage(); + public Pair> sendMessageReaction( + String emoji, boolean remove, String targetAuthor, long targetSentTimestamp, List recipients + ) throws IOException, InvalidNumberException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, + remove, + canonicalizeAndResolveSignalServiceAddress(targetAuthor), + targetSentTimestamp); + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withReaction(reaction); + return sendMessage(messageBuilder, getSignalServiceAddresses(recipients)); + } + + public Pair> sendEndSessionMessage(List recipients) throws IOException, InvalidNumberException { + SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().asEndSessionMessage(); - sendMessageLegacy(messageBuilder, recipients); + final Collection signalServiceAddresses = getSignalServiceAddresses(recipients); + try { + return sendMessage(messageBuilder, signalServiceAddresses); + } catch (Exception e) { + for (SignalServiceAddress address : signalServiceAddresses) { + handleEndSession(address); + } + account.save(); + throw e; + } } - @Override - public String getContactName(String number) { - ContactInfo contact = account.getContactStore().getContact(number); + public String getContactName(String number) throws InvalidNumberException { + ContactInfo contact = account.getContactStore().getContact(canonicalizeAndResolveSignalServiceAddress(number)); if (contact == null) { return ""; } else { @@ -567,82 +994,217 @@ public class Manager implements Signal { } } - @Override - public void setContactName(String number, String name) { - ContactInfo contact = account.getContactStore().getContact(number); + public void setContactName(String number, String name) throws InvalidNumberException { + final SignalServiceAddress address = canonicalizeAndResolveSignalServiceAddress(number); + ContactInfo contact = account.getContactStore().getContact(address); if (contact == null) { - contact = new ContactInfo(); - contact.number = number; - System.err.println("Add contact " + number + " named " + name); - } else { - System.err.println("Updating contact " + number + " name " + contact.name + " -> " + name); + contact = new ContactInfo(address); } contact.name = name; account.getContactStore().updateContact(contact); account.save(); } - @Override - public List getGroupIds() { - List groups = getGroups(); - List ids = new ArrayList<>(groups.size()); - for (GroupInfo group : groups) { - ids.add(group.groupId); + public void setContactBlocked(String number, boolean blocked) throws InvalidNumberException { + setContactBlocked(canonicalizeAndResolveSignalServiceAddress(number), blocked); + } + + private void setContactBlocked(SignalServiceAddress address, boolean blocked) { + ContactInfo contact = account.getContactStore().getContact(address); + if (contact == null) { + contact = new ContactInfo(address); } - return ids; + contact.blocked = blocked; + account.getContactStore().updateContact(contact); + account.save(); } - @Override - public String getGroupName(byte[] groupId) { + public void setGroupBlocked(final byte[] groupId, final boolean blocked) throws GroupNotFoundException { GroupInfo group = getGroup(groupId); if (group == null) { - return ""; - } else { - return group.name; + throw new GroupNotFoundException(groupId); } + + group.setBlocked(blocked); + account.getGroupStore().updateGroup(group); + account.save(); } - @Override - public List getGroupMembers(byte[] groupId) { - GroupInfo group = getGroup(groupId); - if (group == null) { - return new ArrayList<>(); + public Pair> updateGroup( + byte[] groupId, String name, List members, String avatar + ) throws IOException, GroupNotFoundException, AttachmentInvalidException, InvalidNumberException, NotAGroupMemberException { + 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 group + */ + public void setExpirationTimer(byte[] groupId, int messageExpirationTimer) { + GroupInfo g = account.getGroupStore().getGroup(groupId); + if (g instanceof GroupInfoV1) { + GroupInfoV1 groupInfoV1 = (GroupInfoV1) g; + groupInfoV1.messageExpirationTime = messageExpirationTimer; + account.getGroupStore().updateGroup(groupInfoV1); } else { - return new ArrayList<>(group.members); + throw new RuntimeException("TODO Not implemented!"); } } - @Override - public byte[] updateGroup(byte[] groupId, String name, List members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException { - if (groupId.length == 0) { - groupId = null; + /** + * Upload the sticker pack from path. + * + * @param path Path can be a path to a manifest.json file or to a zip file that contains a manifest.json file + * @return if successful, returns the URL to install the sticker pack in the signal app + */ + public String uploadStickerPack(String path) throws IOException, StickerPackInvalidException { + SignalServiceStickerManifestUpload manifest = getSignalServiceStickerManifestUpload(path); + + SignalServiceMessageSender messageSender = createMessageSender(); + + byte[] packKey = KeyUtils.createStickerUploadKey(); + String packId = messageSender.uploadStickerManifest(manifest, packKey); + + Sticker sticker = new Sticker(Hex.fromStringCondensed(packId), packKey); + account.getStickerStore().updateSticker(sticker); + account.save(); + + try { + return new URI("https", + "signal.art", + "/addstickers/", + "pack_id=" + URLEncoder.encode(packId, StandardCharsets.UTF_8) + "&pack_key=" + URLEncoder.encode( + Hex.toStringCondensed(packKey), + StandardCharsets.UTF_8)).toString(); + } catch (URISyntaxException e) { + throw new AssertionError(e); } - if (name.isEmpty()) { - name = null; + } + + private SignalServiceStickerManifestUpload getSignalServiceStickerManifestUpload( + final String path + ) throws IOException, StickerPackInvalidException { + ZipFile zip = null; + String rootPath = null; + + final File file = new File(path); + if (file.getName().endsWith(".zip")) { + zip = new ZipFile(file); + } else if (file.getName().equals("manifest.json")) { + rootPath = file.getParent(); + } else { + throw new StickerPackInvalidException("Could not find manifest.json"); } - if (members.size() == 0) { - members = null; + + JsonStickerPack pack = parseStickerPack(rootPath, zip); + + if (pack.stickers == null) { + throw new StickerPackInvalidException("Must set a 'stickers' field."); } - if (avatar.isEmpty()) { - avatar = null; + + if (pack.stickers.isEmpty()) { + throw new StickerPackInvalidException("Must include stickers."); } - return sendUpdateGroupMessage(groupId, name, members, avatar); + + List stickers = new ArrayList<>(pack.stickers.size()); + for (JsonStickerPack.JsonSticker sticker : pack.stickers) { + if (sticker.file == null) { + throw new StickerPackInvalidException("Must set a 'file' field on each sticker."); + } + + Pair data; + try { + data = getInputStreamAndLength(rootPath, zip, sticker.file); + } catch (IOException ignored) { + throw new StickerPackInvalidException("Could not find find " + sticker.file); + } + + 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); + } + + StickerInfo cover = null; + if (pack.cover != null) { + if (pack.cover.file == null) { + throw new StickerPackInvalidException("Must set a 'file' field on the cover."); + } + + Pair data; + try { + data = getInputStreamAndLength(rootPath, zip, pack.cover.file); + } catch (IOException ignored) { + throw new StickerPackInvalidException("Could not find find " + pack.cover.file); + } + + 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(pack.title, pack.author, cover, stickers); } - /** - * Change the expiration timer for a thread (number of groupId) - * - * @param numberOrGroupId - * @param messageExpirationTimer - */ - public void setExpirationTimer(String numberOrGroupId, int messageExpirationTimer) { - ThreadInfo thread = account.getThreadStore().getThread(numberOrGroupId); - thread.messageExpirationTime = messageExpirationTimer; - account.getThreadStore().updateThread(thread); + private static JsonStickerPack parseStickerPack(String rootPath, ZipFile zip) throws IOException { + InputStream inputStream; + if (zip != null) { + inputStream = zip.getInputStream(zip.getEntry("manifest.json")); + } else { + inputStream = new FileInputStream((new File(rootPath, "manifest.json"))); + } + return new ObjectMapper().readValue(inputStream, JsonStickerPack.class); + } + + private static Pair getInputStreamAndLength( + final String rootPath, final ZipFile zip, final String subfile + ) throws IOException { + if (zip != null) { + final ZipEntry entry = zip.getEntry(subfile); + return new Pair<>(zip.getInputStream(entry), entry.getSize()); + } else { + final File file = new File(rootPath, subfile); + return new Pair<>(new FileInputStream(file), file.length()); + } } - private void requestSyncGroups() throws IOException { - SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS).build(); + 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 { sendSyncMessage(message); @@ -651,8 +1213,10 @@ public class Manager implements Signal { } } - private void requestSyncContacts() throws IOException { - SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS).build(); + 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 { sendSyncMessage(message); @@ -661,8 +1225,10 @@ public class Manager implements Signal { } } - private void requestSyncBlocked() throws IOException { - SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.BLOCKED).build(); + 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 { sendSyncMessage(message); @@ -671,8 +1237,10 @@ public class Manager implements Signal { } } - private void requestSyncConfiguration() throws IOException { - SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONFIGURATION).build(); + 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 { sendSyncMessage(message); @@ -681,228 +1249,335 @@ public class Manager implements Signal { } } - private byte[] getSelfUnidentifiedAccessKey() { - return UnidentifiedAccess.deriveAccessKeyFrom(account.getProfileKey()); - } - - private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) { - // TODO implement - return null; - } - - private Optional getAccessForSync() { - // TODO implement - return Optional.absent(); - } - - private List> getAccessFor(Collection recipients) { - List> result = new ArrayList<>(recipients.size()); - for (SignalServiceAddress recipient : recipients) { - result.add(Optional.absent()); + 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; } - return result; - } - - private Optional getAccessFor(SignalServiceAddress recipient) { - // TODO implement - return Optional.absent(); + // TODO cache for a day + return certificate; } - private void sendSyncMessage(SignalServiceSyncMessage message) - throws IOException, UntrustedIdentityException { - SignalServiceMessageSender messageSender = new SignalServiceMessageSender(BaseConfig.serviceConfiguration, username, account.getPassword(), - account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent()); + private void sendSyncMessage(SignalServiceSyncMessage message) throws IOException, UntrustedIdentityException { + SignalServiceMessageSender messageSender = createMessageSender(); try { - messageSender.sendMessage(message, getAccessForSync()); + messageSender.sendMessage(message, unidentifiedAccessHelper.getAccessForSync()); } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore() + .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), + e.getIdentityKey(), + TrustLevel.UNTRUSTED); throw e; } } - /** - * This method throws an EncapsulatedExceptions exception instead of returning a list of SendMessageResult. - */ - private void sendMessageLegacy(SignalServiceDataMessage.Builder messageBuilder, Collection recipients) - throws EncapsulatedExceptions, IOException { - List results = sendMessage(messageBuilder, recipients); - - List untrustedIdentities = new LinkedList<>(); - List unregisteredUsers = new LinkedList<>(); - List networkExceptions = new LinkedList<>(); - - for (SendMessageResult result : results) { - if (result.isUnregisteredFailure()) { - unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getNumber(), null)); - } else if (result.isNetworkFailure()) { - networkExceptions.add(new NetworkFailureException(result.getAddress().getNumber(), null)); - } else if (result.getIdentityFailure() != null) { - untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getNumber(), result.getIdentityFailure().getIdentityKey())); - } - } - if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) { - throw new EncapsulatedExceptions(untrustedIdentities, unregisteredUsers, networkExceptions); - } - } + private Collection getSignalServiceAddresses(Collection numbers) throws InvalidNumberException { + final Set signalServiceAddresses = new HashSet<>(numbers.size()); - private List sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection recipients) - throws IOException { - Set recipientsTS = Utils.getSignalServiceAddresses(recipients, username); - if (recipientsTS == null) { - account.save(); - return Collections.emptyList(); + for (String number : numbers) { + signalServiceAddresses.add(canonicalizeAndResolveSignalServiceAddress(number)); } + return signalServiceAddresses; + } + private Pair> sendMessage( + SignalServiceDataMessage.Builder messageBuilder, Collection recipients + ) throws IOException { + recipients = recipients.stream().map(this::resolveSignalServiceAddress).collect(Collectors.toSet()); + final long timestamp = System.currentTimeMillis(); + messageBuilder.withTimestamp(timestamp); + getOrCreateMessagePipe(); + getOrCreateUnidentifiedMessagePipe(); SignalServiceDataMessage message = null; try { - SignalServiceMessageSender messageSender = new SignalServiceMessageSender(BaseConfig.serviceConfiguration, username, account.getPassword(), - account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent()); - message = messageBuilder.build(); - if (message.getGroupInfo().isPresent()) { + if (message.getGroupContext().isPresent()) { try { - List result = messageSender.sendMessage(new ArrayList<>(recipientsTS), getAccessFor(recipientsTS), message); + SignalServiceMessageSender messageSender = createMessageSender(); + final boolean isRecipientUpdate = false; + List result = messageSender.sendMessage(new ArrayList<>(recipients), + unidentifiedAccessHelper.getAccessFor(recipients), + isRecipientUpdate, + message); for (SendMessageResult r : result) { if (r.getIdentityFailure() != null) { - account.getSignalProtocolStore().saveIdentity(r.getAddress().getNumber(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore() + .saveIdentity(r.getAddress(), + r.getIdentityFailure().getIdentityKey(), + TrustLevel.UNTRUSTED); } } - return result; + return new Pair<>(timestamp, result); } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED); - return Collections.emptyList(); + account.getSignalProtocolStore() + .saveIdentity(resolveSignalServiceAddress(e.getIdentifier()), + e.getIdentityKey(), + TrustLevel.UNTRUSTED); + return new Pair<>(timestamp, Collections.emptyList()); } } else { // Send to all individually, so sync messages are sent correctly - List results = new ArrayList<>(recipientsTS.size()); - for (SignalServiceAddress address : recipientsTS) { - ThreadInfo thread = account.getThreadStore().getThread(address.getNumber()); - if (thread != null) { - messageBuilder.withExpiration(thread.messageExpirationTime); + List results = new ArrayList<>(recipients.size()); + for (SignalServiceAddress address : recipients) { + 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.getE164Number(), 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; + return new Pair<>(timestamp, results); } } finally { if (message != null && message.isEndSession()) { - for (SignalServiceAddress recipient : recipientsTS) { - handleEndSession(recipient.getNumber()); + for (SignalServiceAddress recipient : recipients) { + handleEndSession(recipient); } } account.save(); } } - private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, ProtocolUntrustedIdentityException, SelfSendException { - SignalServiceCipher cipher = new SignalServiceCipher(new SignalServiceAddress(username), account.getSignalProtocolStore(), Utils.getCertificateValidator()); + private SendMessageResult sendSelfMessage(SignalServiceDataMessage message) throws IOException { + SignalServiceMessageSender messageSender = createMessageSender(); + + SignalServiceAddress recipient = account.getSelfAddress(); + + final Optional unidentifiedAccess = unidentifiedAccessHelper.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 { + long startTime = System.currentTimeMillis(); + messageSender.sendMessage(syncMessage, unidentifiedAccess); + return SendMessageResult.success(recipient, + unidentifiedAccess.isPresent(), + false, + System.currentTimeMillis() - startTime); + } 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 = createMessageSender(); + + try { + return messageSender.sendMessage(address, unidentifiedAccessHelper.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, String source, String destination, boolean ignoreAttachments) { - String threadId; - if (message.getGroupInfo().isPresent()) { - SignalServiceGroup groupInfo = message.getGroupInfo().get(); - threadId = Base64.encodeBytes(groupInfo.getGroupId()); - GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId()); - switch (groupInfo.getType()) { - case UPDATE: - if (group == null) { - group = new GroupInfo(groupInfo.getGroupId()); - } + private static int currentTimeDays() { + return (int) TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis()); + } + + private GroupsV2AuthorizationString getGroupAuthForToday( + final GroupSecretParams groupSecretParams + ) throws IOException, VerificationFailedException { + final int today = currentTimeDays(); + // Returns credentials for the next 7 days + final HashMap credentials = groupsV2Api.getCredentials(today); + // TODO cache credentials until they expire + AuthCredentialResponse authCredentialResponse = credentials.get(today); + return groupsV2Api.getGroupsV2AuthorizationString(account.getUuid(), + today, + groupSecretParams, + authCredentialResponse); + } + + private List handleSignalServiceDataMessage( + SignalServiceDataMessage message, + boolean isSync, + SignalServiceAddress source, + SignalServiceAddress destination, + boolean ignoreAttachments + ) { + List actions = new ArrayList<>(); + if (message.getGroupContext().isPresent()) { + if (message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); + GroupInfo group = account.getGroupStore().getGroup(groupInfo.getGroupId()); + if (group == null || group instanceof GroupInfoV1) { + GroupInfoV1 groupV1 = (GroupInfoV1) group; + switch (groupInfo.getType()) { + case UPDATE: { + if (groupV1 == null) { + groupV1 = new GroupInfoV1(groupInfo.getGroupId()); + } - if (groupInfo.getAvatar().isPresent()) { - SignalServiceAttachment avatar = groupInfo.getAvatar().get(); - 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()); + if (groupInfo.getAvatar().isPresent()) { + SignalServiceAttachment avatar = groupInfo.getAvatar().get(); + if (avatar.isPointer()) { + try { + retrieveGroupAvatarAttachment(avatar.asPointer(), groupV1.groupId); + } catch (IOException | InvalidMessageException | MissingConfigurationException e) { + System.err.println("Failed to retrieve group avatar (" + avatar.asPointer() + .getRemoteId() + "): " + e.getMessage()); + } + } } - } - } - if (groupInfo.getName().isPresent()) { - group.name = groupInfo.getName().get(); - } + if (groupInfo.getName().isPresent()) { + groupV1.name = groupInfo.getName().get(); + } - if (groupInfo.getMembers().isPresent()) { - group.members.addAll(groupInfo.getMembers().get()); - } + if (groupInfo.getMembers().isPresent()) { + groupV1.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(); + account.getGroupStore().updateGroup(groupV1); + break; } - } - break; - case QUIT: - if (group == null) { - try { - sendGroupInfoRequest(groupInfo.getGroupId(), source); - } catch (IOException | EncapsulatedExceptions e) { - e.printStackTrace(); + case DELIVER: + if (groupV1 == null && !isSync) { + actions.add(new SendGroupInfoRequestAction(source, groupInfo.getGroupId())); + } + break; + case QUIT: { + if (groupV1 != null) { + groupV1.removeMember(source); + account.getGroupStore().updateGroup(groupV1); + } + break; } - } else { - group.members.remove(source); - account.getGroupStore().updateGroup(group); + case REQUEST_INFO: + if (groupV1 != null && !isSync) { + actions.add(new SendGroupUpdateAction(source, groupV1.groupId)); + } + break; } - break; - case REQUEST_INFO: - if (group != null) { + } else { + System.err.println("Received a group v1 message for a v2 group: " + group.getTitle()); + } + } + if (message.getGroupContext().get().getGroupV2().isPresent()) { + final SignalServiceGroupV2 groupContext = message.getGroupContext().get().getGroupV2().get(); + final GroupMasterKey groupMasterKey = groupContext.getMasterKey(); + + final GroupSecretParams groupSecretParams = GroupSecretParams.deriveFromMasterKey(groupMasterKey); + + byte[] groupId = groupSecretParams.getPublicParams().getGroupIdentifier().serialize(); + GroupInfo groupInfo = account.getGroupStore().getGroup(groupId); + if (groupInfo instanceof GroupInfoV1) { + // TODO upgrade group + } else if (groupInfo == null || groupInfo instanceof GroupInfoV2) { + GroupInfoV2 groupInfoV2 = groupInfo == null + ? new GroupInfoV2(groupId, groupMasterKey) + : (GroupInfoV2) groupInfo; + + if (groupInfoV2.getGroup() == null + || groupInfoV2.getGroup().getRevision() < groupContext.getRevision()) { + // TODO check if revision is only 1 behind and a signedGroupChange is available 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 + final GroupsV2AuthorizationString groupsV2AuthorizationString = getGroupAuthForToday( + groupSecretParams); + final DecryptedGroup group = groupsV2Api.getGroup(groupSecretParams, + groupsV2AuthorizationString); + groupInfoV2.setGroup(group); + for (DecryptedMember member : group.getMembersList()) { + final SignalServiceAddress address = resolveSignalServiceAddress(new SignalServiceAddress( + UuidUtil.parseOrThrow(member.getUuid().toByteArray()), + null)); + try { + account.getProfileStore() + .storeProfileKey(address, + new ProfileKey(member.getProfileKey().toByteArray())); + } catch (InvalidInputException ignored) { + } + } + } catch (IOException | VerificationFailedException | InvalidGroupStateException e) { + System.err.println("Failed to retrieve Group V2 info, ignoring ..."); } + account.getGroupStore().updateGroup(groupInfoV2); } - break; - } - } else { - if (isSync) { - threadId = destination; - } else { - threadId = source; + } } } + final SignalServiceAddress conversationPartnerAddress = isSync ? destination : source; if (message.isEndSession()) { - handleEndSession(isSync ? destination : source); + 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()) { + if (message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); + GroupInfoV1 group = account.getGroupStore().getOrCreateGroupV1(groupInfo.getGroupId()); + if (group != null) { + if (group.messageExpirationTime != message.getExpiresInSeconds()) { + group.messageExpirationTime = message.getExpiresInSeconds(); + account.getGroupStore().updateGroup(group); + } + } + } else if (message.getGroupContext().get().getGroupV2().isPresent()) { + // disappearing message timer already stored in the DecryptedGroup + } + } 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) { @@ -910,32 +1585,64 @@ 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(username)) { - this.account.setProfileKey(message.getProfileKey().get()); + final ProfileKey profileKey; + try { + profileKey = new ProfileKey(message.getProfileKey().get()); + } catch (InvalidInputException e) { + throw new AssertionError(e); + } + if (source.matches(account.getSelfAddress())) { + this.account.setProfileKey(profileKey); + } + this.account.getProfileStore().storeProfileKey(source, profileKey); + } + if (message.getPreviews().isPresent()) { + final List previews = message.getPreviews().get(); + for (SignalServiceDataMessage.Preview preview : previews) { + if (preview.getImage().isPresent() && preview.getImage().get().isPointer()) { + SignalServiceAttachmentPointer attachment = preview.getImage().get().asPointer(); + try { + retrieveAttachment(attachment); + } catch (IOException | InvalidMessageException | MissingConfigurationException e) { + System.err.println("Failed to retrieve attachment (" + + attachment.getRemoteId() + + "): " + + e.getMessage()); + } + } } - ContactInfo contact = account.getContactStore().getContact(source); - if (contact == null) { - contact = new ContactInfo(); - contact.number = source; + } + if (message.getSticker().isPresent()) { + final SignalServiceDataMessage.Sticker messageSticker = message.getSticker().get(); + Sticker sticker = account.getStickerStore().getSticker(messageSticker.getPackId()); + if (sticker == null) { + sticker = new Sticker(messageSticker.getPackId(), messageSticker.getPackKey()); + account.getStickerStore().updateSticker(sticker); } - contact.profileKey = Base64.encodeBytes(message.getProfileKey().get()); } + return actions; } - private void retryFailedReceivedMessages(ReceiveMessageHandler handler, boolean ignoreAttachments) { + private void retryFailedReceivedMessages( + ReceiveMessageHandler handler, boolean ignoreAttachments + ) { final File cachePath = new File(getMessageCachePath()); if (!cachePath.exists()) { return; } for (final File dir : Objects.requireNonNull(cachePath.listFiles())) { if (!dir.isDirectory()) { + retryFailedReceivedMessage(handler, ignoreAttachments, dir); continue; } @@ -943,159 +1650,282 @@ public class Manager implements Signal { if (!fileEntry.isFile()) { continue; } - SignalServiceEnvelope envelope; - try { - envelope = Utils.loadEnvelope(fileEntry); - if (envelope == null) { - continue; - } - } catch (IOException 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); + 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 (org.whispersystems.libsignal.UntrustedIdentityException e) { + return; + } catch (Exception er) { + // All other errors are not recoverable, so delete the cached message try { Files.delete(fileEntry.toPath()); } catch (IOException e) { System.err.println("Failed to delete cached message file “" + fileEntry + "”: " + e.getMessage()); } + return; } - // Try to delete directory if empty - dir.delete(); + List actions = handleMessage(envelope, content, ignoreAttachments); + for (HandleAction action : actions) { + try { + action.execute(this); + } catch (Throwable e) { + e.printStackTrace(); + } + } + } + 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()); } } - public void receiveMessages(long timeout, TimeUnit unit, boolean returnOnTimeout, boolean ignoreAttachments, ReceiveMessageHandler handler) throws IOException { + public void receiveMessages( + long timeout, + TimeUnit unit, + boolean returnOnTimeout, + boolean ignoreAttachments, + ReceiveMessageHandler handler + ) throws IOException { retryFailedReceivedMessages(handler, ignoreAttachments); - final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(BaseConfig.serviceConfiguration, username, account.getPassword(), account.getDeviceId(), account.getSignalingKey(), BaseConfig.USER_AGENT, null, timer); - 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, new SignalServiceMessagePipe.MessagePipeCallback() { - @Override - public void onMessage(SignalServiceEnvelope envelope) { - // store message on disk, before acknowledging receipt to the server + getOrCreateMessagePipe(); + + 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 { + 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 { - File cacheFile = getMessageCacheFile(envelope.getSource(), now, envelope.getTimestamp()); - Utils.storeEnvelope(envelope, cacheFile); - } catch (IOException e) { - System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage()); + action.execute(this); + } catch (Throwable e) { + e.printStackTrace(); } } - }); - } catch (TimeoutException e) { - if (returnOnTimeout) - return; - continue; - } catch (InvalidVersionException e) { - System.err.println("Ignoring error: " + e.getMessage()); + account.save(); + queuedActions.clear(); + queuedActions = null; + } + + // Continue to wait another timeout for new messages continue; } - if (!envelope.isReceipt()) { - try { - content = decryptMessage(envelope); - } catch (Exception e) { - exception = e; + } 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; + } + List actions = handleMessage(envelope, content, ignoreAttachments); + if (hasCaughtUpWithOldMessages) { + for (HandleAction action : actions) { + try { + action.execute(this); + } catch (Throwable e) { + e.printStackTrace(); + } } - handleMessage(envelope, content, ignoreAttachments); + } else { + if (queuedActions == null) { + queuedActions = new HashSet<>(); + } + queuedActions.addAll(actions); } - account.save(); + } + account.save(); + if (!isMessageBlocked(envelope, content)) { handler.handleMessage(envelope, content, exception); - if (!(exception instanceof ProtocolUntrustedIdentityException)) { - File cacheFile = null; - try { - cacheFile = getMessageCacheFile(envelope.getSource(), 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()); - } + } + 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()); } } - } finally { - if (messagePipe != null) { - messagePipe.shutdown(); - messagePipe = null; + } + } + + private boolean isMessageBlocked( + SignalServiceEnvelope envelope, SignalServiceContent content + ) { + SignalServiceAddress source; + if (!envelope.isUnidentifiedSender() && envelope.hasSource()) { + source = envelope.getSourceAddress(); + } else if (content != null) { + source = content.getSender(); + } else { + return false; + } + 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.getGroupContext().isPresent() && message.getGroupContext().get().getGroupV1().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupContext().get().getGroupV1().get(); + GroupInfo group = getGroup(groupInfo.getGroupId()); + return groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.isBlocked(); } } + 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()) { + sender = envelope.getSourceAddress(); + } 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, envelope.getSource(), username, 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()) { - SignalServiceDataMessage message = syncMessage.getSent().get().getMessage(); - handleSignalServiceDataMessage(message, true, envelope.getSource(), syncMessage.getSent().get().getDestination().get(), ignoreAttachments); + SentTranscriptMessage message = syncMessage.getSent().get(); + 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()) { + actions.add(SendSyncBlockedListAction.create()); } - // TODO Handle rm.isBlockedListRequest(); rm.isConfigurationRequest(); + // TODO Handle rm.isConfigurationRequest(); rm.isKeysRequest(); } if (syncMessage.getGroups().isPresent()) { File tmpFile = null; try { tmpFile = IOUtils.createTempFile(); - try (InputStream attachmentAsStream = retrieveAttachmentAsStream(syncMessage.getGroups().get().asPointer(), tmpFile)) { + try (InputStream attachmentAsStream = retrieveAttachmentAsStream(syncMessage.getGroups() + .get() + .asPointer(), tmpFile)) { DeviceGroupsInputStream s = new DeviceGroupsInputStream(attachmentAsStream); DeviceGroup g; while ((g = s.read()) != null) { - GroupInfo syncGroup = account.getGroupStore().getGroup(g.getId()); - if (syncGroup == null) { - syncGroup = new GroupInfo(g.getId()); + GroupInfoV1 syncGroup = account.getGroupStore().getOrCreateGroupV1(g.getId()); + if (syncGroup != null) { + if (g.getName().isPresent()) { + syncGroup.name = g.getName().get(); + } + syncGroup.addMembers(g.getMembers() + .stream() + .map(this::resolveSignalServiceAddress) + .collect(Collectors.toSet())); + if (!g.isActive()) { + syncGroup.removeMember(account.getSelfAddress()); + } else { + // Add ourself to the member set as it's marked as active + syncGroup.addMembers(Collections.singleton(account.getSelfAddress())); + } + syncGroup.blocked = g.isBlocked(); + if (g.getColor().isPresent()) { + syncGroup.color = g.getColor().get(); + } + + if (g.getAvatar().isPresent()) { + retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId); + } + syncGroup.inboxPosition = g.getInboxPosition().orNull(); + syncGroup.archived = g.isArchived(); + account.getGroupStore().updateGroup(syncGroup); } - if (g.getName().isPresent()) { - syncGroup.name = g.getName().get(); - } - syncGroup.members.addAll(g.getMembers()); - syncGroup.active = g.isActive(); - if (g.getColor().isPresent()) { - syncGroup.color = g.getColor().get(); - } - - if (g.getAvatar().isPresent()) { - retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId); - } - account.getGroupStore().updateGroup(syncGroup); } } } catch (Exception e) { @@ -1105,33 +1935,48 @@ public class Manager implements Signal { try { Files.delete(tmpFile.toPath()); } catch (IOException e) { - System.err.println("Failed to delete received groups temp file “" + tmpFile + "”: " + e.getMessage()); + System.err.println("Failed to delete received groups temp file “" + + tmpFile + + "”: " + + e.getMessage()); } } } } if (syncMessage.getBlockedList().isPresent()) { - // TODO store list of blocked numbers + final BlockedListMessage blockedListMessage = syncMessage.getBlockedList().get(); + for (SignalServiceAddress address : blockedListMessage.getAddresses()) { + setContactBlocked(resolveSignalServiceAddress(address), true); + } + for (byte[] groupId : blockedListMessage.getGroupIds()) { + try { + setGroupBlocked(groupId, true); + } catch (GroupNotFoundException e) { + System.err.println("BlockedListMessage contained groupID that was not found in GroupStore: " + + Base64.encodeBytes(groupId)); + } + } } if (syncMessage.getContacts().isPresent()) { File tmpFile = null; try { tmpFile = IOUtils.createTempFile(); final ContactsMessage contactsMessage = syncMessage.getContacts().get(); - try (InputStream attachmentAsStream = retrieveAttachmentAsStream(contactsMessage.getContactsStream().asPointer(), tmpFile)) { + try (InputStream attachmentAsStream = retrieveAttachmentAsStream(contactsMessage.getContactsStream() + .asPointer(), tmpFile)) { DeviceContactsInputStream s = new DeviceContactsInputStream(attachmentAsStream); if (contactsMessage.isComplete()) { account.getContactStore().clear(); } DeviceContact c; while ((c = s.read()) != null) { - if (c.getNumber().equals(account.getUsername()) && c.getProfileKey().isPresent()) { + if (c.getAddress().matches(account.getSelfAddress()) && c.getProfileKey().isPresent()) { account.setProfileKey(c.getProfileKey().get()); } - ContactInfo contact = account.getContactStore().getContact(c.getNumber()); + final SignalServiceAddress address = resolveSignalServiceAddress(c.getAddress()); + ContactInfo contact = account.getContactStore().getContact(address); if (contact == null) { - contact = new ContactInfo(); - contact.number = c.getNumber(); + contact = new ContactInfo(address); } if (c.getName().isPresent()) { contact.name = c.getName().get(); @@ -1140,20 +1985,21 @@ public class Manager implements Signal { contact.color = c.getColor().get(); } if (c.getProfileKey().isPresent()) { - contact.profileKey = Base64.encodeBytes(c.getProfileKey().get()); + account.getProfileStore().storeProfileKey(address, c.getProfileKey().get()); } if (c.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = c.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination(), 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.getNumber()); - thread.messageExpirationTime = c.getExpirationTimer().get(); - account.getThreadStore().updateThread(thread); - } - if (c.isBlocked()) { - // TODO store list of blocked numbers + contact.messageExpirationTime = c.getExpirationTimer().get(); } + contact.blocked = c.isBlocked(); + contact.inboxPosition = c.getInboxPosition().orNull(); + contact.archived = c.isArchived(); account.getContactStore().updateContact(contact); if (c.getAvatar().isPresent()) { @@ -1168,28 +2014,56 @@ public class Manager implements Signal { try { Files.delete(tmpFile.toPath()); } catch (IOException e) { - System.err.println("Failed to delete received contacts temp file “" + tmpFile + "”: " + e.getMessage()); + System.err.println("Failed to delete received contacts temp file “" + + tmpFile + + "”: " + + e.getMessage()); } } } } if (syncMessage.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = syncMessage.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + account.getSignalProtocolStore() + .setIdentityTrustLevel(resolveSignalServiceAddress(verifiedMessage.getDestination()), + verifiedMessage.getIdentityKey(), + TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + } + if (syncMessage.getStickerPackOperations().isPresent()) { + final List stickerPackOperationMessages = syncMessage.getStickerPackOperations() + .get(); + for (StickerPackOperationMessage m : stickerPackOperationMessages) { + if (!m.getPackId().isPresent()) { + continue; + } + Sticker sticker = account.getStickerStore().getSticker(m.getPackId().get()); + if (sticker == null) { + if (!m.getPackKey().isPresent()) { + continue; + } + sticker = new Sticker(m.getPackId().get(), m.getPackKey().get()); + } + sticker.setInstalled(!m.getType().isPresent() + || m.getType().get() == StickerPackOperationMessage.Type.INSTALL); + account.getStickerStore().updateSticker(sticker); + } } 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); @@ -1200,11 +2074,13 @@ 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); @@ -1214,16 +2090,46 @@ 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 retrieveProfileAvatar( + SignalServiceAddress address, String avatarPath, ProfileKey profileKey + ) throws IOException { + IOUtils.createPrivateDirectories(pathConfig.getAvatarsPath()); + SignalServiceMessageReceiver receiver = getOrCreateMessageReceiver(); + 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 { - IOUtils.createPrivateDirectories(attachmentsPath); - return retrieveAttachment(pointer, getAttachmentFile(pointer.getId()), true); + 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)) { @@ -1235,53 +2141,53 @@ public class Manager implements Signal { } } - final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(BaseConfig.serviceConfiguration, username, account.getPassword(), account.getDeviceId(), account.getSignalingKey(), BaseConfig.USER_AGENT, null, timer); + final SignalServiceMessageReceiver messageReceiver = getOrCreateMessageReceiver(); 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()); } catch (IOException e) { - System.err.println("Failed to delete received attachment temp file “" + tmpFile + "”: " + e.getMessage()); + System.err.println("Failed to delete received attachment temp file “" + + tmpFile + + "”: " + + e.getMessage()); } } return outputFile; } - private InputStream retrieveAttachmentAsStream(SignalServiceAttachmentPointer pointer, File tmpFile) throws IOException, InvalidMessageException { - final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(BaseConfig.serviceConfiguration, username, account.getPassword(), account.getDeviceId(), account.getSignalingKey(), BaseConfig.USER_AGENT, null, timer); - return messageReceiver.retrieveAttachment(pointer, tmpFile, BaseConfig.MAX_ATTACHMENT_SIZE); - } - - @Override - public boolean isRemote() { - return false; + private InputStream retrieveAttachmentAsStream( + SignalServiceAttachmentPointer pointer, File tmpFile + ) throws IOException, InvalidMessageException, MissingConfigurationException { + final SignalServiceMessageReceiver messageReceiver = getOrCreateMessageReceiver(); + 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.members), createGroupAvatarAttachment(record.groupId), - record.active, Optional.fromNullable(info != null ? info.messageExpirationTime : null), - Optional.fromNullable(record.color), false)); + if (record instanceof GroupInfoV1) { + GroupInfoV1 groupInfo = (GroupInfoV1) record; + out.write(new DeviceGroup(groupInfo.groupId, + Optional.fromNullable(groupInfo.name), + new ArrayList<>(groupInfo.getMembers()), + createGroupAvatarAttachment(groupInfo.groupId), + groupInfo.isMember(account.getSelfAddress()), + Optional.of(groupInfo.messageExpirationTime), + Optional.fromNullable(groupInfo.color), + groupInfo.blocked, + Optional.fromNullable(groupInfo.inboxPosition), + groupInfo.archived)); + } } } @@ -1305,7 +2211,7 @@ public class Manager implements Signal { } } - private void sendContacts() throws IOException, UntrustedIdentityException { + public void sendContacts() throws IOException, UntrustedIdentityException { File contactsFile = IOUtils.createTempFile(); try { @@ -1313,34 +2219,40 @@ 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.number, 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()); } - byte[] profileKey = record.profileKey == null ? null : Base64.decode(record.profileKey); - // TODO store list of blocked numbers - boolean blocked = false; - out.write(new DeviceContact(record.number, Optional.fromNullable(record.name), - createContactAvatarAttachment(record.number), Optional.fromNullable(record.color), - Optional.fromNullable(verifiedMessage), Optional.fromNullable(profileKey), blocked, Optional.fromNullable(info != null ? info.messageExpirationTime : null))); + ProfileKey profileKey = account.getProfileStore().getProfileKey(record.getAddress()); + 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.of(record.messageExpirationTime), + Optional.fromNullable(record.inboxPosition), + record.archived)); } if (account.getProfileKey() != null) { // Send our own profile key as well - out.write(new DeviceContact(account.getUsername(), - Optional.absent(), Optional.absent(), - Optional.absent(), Optional.absent(), + out.write(new DeviceContact(account.getSelfAddress(), + Optional.absent(), + Optional.absent(), + Optional.absent(), + Optional.absent(), Optional.of(account.getProfileKey()), - false, Optional.absent())); + false, + Optional.absent(), + Optional.absent(), + false)); } } @@ -1364,25 +2276,55 @@ public class Manager implements Signal { } } - private void sendVerifiedMessage(String destination, IdentityKey identityKey, TrustLevel trustLevel) throws IOException, UntrustedIdentityException { - VerifiedMessage verifiedMessage = new VerifiedMessage(destination, identityKey, trustLevel.toVerifiedState(), System.currentTimeMillis()); + void sendBlockedList() throws IOException, UntrustedIdentityException { + List addresses = new ArrayList<>(); + for (ContactInfo record : account.getContactStore().getContacts()) { + if (record.blocked) { + addresses.add(record.getAddress()); + } + } + List groupIds = new ArrayList<>(); + for (GroupInfo record : account.getGroupStore().getGroups()) { + if (record.isBlocked()) { + groupIds.add(record.groupId); + } + } + sendSyncMessage(SignalServiceSyncMessage.forBlocked(new BlockedListMessage(addresses, groupIds))); + } + + private void sendVerifiedMessage( + SignalServiceAddress destination, IdentityKey identityKey, TrustLevel trustLevel + ) throws IOException, UntrustedIdentityException { + VerifiedMessage verifiedMessage = new VerifiedMessage(destination, + identityKey, + trustLevel.toVerifiedState(), + System.currentTimeMillis()); sendSyncMessage(SignalServiceSyncMessage.forVerified(verifiedMessage)); } + public List getContacts() { + return account.getContactStore().getContacts(); + } + 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 byte[] getGroupId(GroupMasterKey groupMasterKey) { + final GroupSecretParams groupSecretParams = GroupSecretParams.deriveFromMasterKey(groupMasterKey); + return groupSecretParams.getPublicParams().getGroupIdentifier().serialize(); + } + + public List getIdentities() { return account.getSignalProtocolStore().getIdentities(); } - public List getIdentities(String number) { - return account.getSignalProtocolStore().getIdentities(number); + public List getIdentities(String number) throws InvalidNumberException { + return account.getSignalProtocolStore().getIdentities(canonicalizeAndResolveSignalServiceAddress(number)); } /** @@ -1391,8 +2333,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; } @@ -1401,9 +2344,10 @@ 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(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1419,19 +2363,21 @@ 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(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1447,15 +2393,17 @@ 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(name, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); + sendVerifiedMessage(address, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1465,8 +2413,53 @@ public class Manager implements Signal { return true; } - public String computeSafetyNumber(String theirUsername, IdentityKey theirIdentityKey) { - return Utils.computeSafetyNumber(username, 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 {