X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/35c72f692f13b12594ecdbe8f59f31d3b396d356..bb06ae9d9a22896e95313d25135676e44ccb1db5:/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 e8860ef8..f5bbe146 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,9 +16,12 @@ */ package org.asamk.signal.manager; -import org.apache.http.util.TextUtils; import org.asamk.Signal; -import org.asamk.signal.*; +import org.asamk.signal.AttachmentInvalidException; +import org.asamk.signal.GroupNotFoundException; +import org.asamk.signal.NotAGroupMemberException; +import org.asamk.signal.TrustLevel; +import org.asamk.signal.UserAlreadyExists; import org.asamk.signal.storage.SignalAccount; import org.asamk.signal.storage.contacts.ContactInfo; import org.asamk.signal.storage.groups.GroupInfo; @@ -27,29 +30,67 @@ import org.asamk.signal.storage.protocol.JsonIdentityKeyStore; import org.asamk.signal.storage.threads.ThreadInfo; import org.asamk.signal.util.IOUtils; import org.asamk.signal.util.Util; -import org.signal.libsignal.metadata.*; -import org.signal.libsignal.metadata.certificate.CertificateValidator; -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.libsignal.metadata.certificate.InvalidCertificateException; +import org.signal.zkgroup.InvalidInputException; +import org.signal.zkgroup.VerificationFailedException; +import org.signal.zkgroup.profiles.ProfileKey; +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; -import org.whispersystems.libsignal.fingerprint.Fingerprint; -import org.whispersystems.libsignal.fingerprint.NumericFingerprintGenerator; 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.messages.SendMessageResult; +import org.whispersystems.signalservice.api.messages.SignalServiceAttachment; +import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentPointer; +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.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.VerifiedMessage; +import org.whispersystems.signalservice.api.profiles.SignalServiceProfile; import org.whispersystems.signalservice.api.push.ContactTokenDetails; import org.whispersystems.signalservice.api.push.SignalServiceAddress; import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException; @@ -57,39 +98,55 @@ import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptio import org.whispersystems.signalservice.api.push.exceptions.NetworkFailureException; import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException; import org.whispersystems.signalservice.api.util.InvalidNumberException; -import org.whispersystems.signalservice.api.util.PhoneNumberFormatter; 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.internal.push.SignalServiceProtos; -import org.whispersystems.signalservice.internal.util.Base64; - -import java.io.*; +import org.whispersystems.signalservice.internal.push.UnsupportedDataMessageException; +import org.whispersystems.util.Base64; + +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.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.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Objects; +import java.util.Set; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class Manager implements Signal { + private static final SignalServiceProfile.Capabilities capabilities = new SignalServiceProfile.Capabilities(false, false); + 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 SignalServiceAccountManager accountManager; private SignalServiceMessagePipe messagePipe = null; private SignalServiceMessagePipe unidentifiedMessagePipe = null; - private SleepTimer timer = new UptimeSleepTimer(); - public Manager(String username, String settingsPath) { this.username = username; this.settingsPath = settingsPath; @@ -99,45 +156,16 @@ public class Manager implements Signal { } - private static List getSignalServiceAttachments(List attachments) throws AttachmentInvalidException { - List SignalServiceAttachments = null; - if (attachments != null) { - SignalServiceAttachments = new ArrayList<>(attachments.size()); - for (String attachment : attachments) { - try { - SignalServiceAttachments.add(createAttachment(new File(attachment))); - } catch (IOException e) { - throw new AttachmentInvalidException(attachment, e); - } - } - } - return SignalServiceAttachments; + public String getUsername() { + return username; } - private static SignalServiceAttachmentStream createAttachment(File attachmentFile) throws IOException { - InputStream attachmentStream = new FileInputStream(attachmentFile); - final long attachmentSize = attachmentFile.length(); - String mime = Files.probeContentType(attachmentFile.toPath()); - if (mime == null) { - mime = "application/octet-stream"; - } - // TODO mabybe add a parameter to set the voiceNote, preview, width, height and caption option - Optional preview = Optional.absent(); - Optional caption = Optional.absent(); - return new SignalServiceAttachmentStream(attachmentStream, mime, attachmentSize, Optional.of(attachmentFile.getName()), false, preview, 0, 0, caption, null); + private SignalServiceAddress getSelfAddress() { + return new SignalServiceAddress(null, username); } - private static CertificateValidator getCertificateValidator() { - try { - ECPublicKey unidentifiedSenderTrustRoot = Curve.decodePoint(Base64.decode(BaseConfig.UNIDENTIFIED_SENDER_TRUST_ROOT), 0); - return new CertificateValidator(unidentifiedSenderTrustRoot); - } catch (InvalidKeyException | IOException e) { - throw new AssertionError(e); - } - } - - public String getUsername() { - return username; + private SignalServiceAccountManager getSignalServiceAccountManager() { + return new SignalServiceAccountManager(BaseConfig.serviceConfiguration, null, account.getUsername(), account.getPassword(), account.getDeviceId(), BaseConfig.USER_AGENT, timer); } private IdentityKey getIdentity() { @@ -163,7 +191,7 @@ public class Manager implements Signal { } public boolean userHasKeys() { - return account.getSignalProtocolStore() != null; + return account != null && account.getSignalProtocolStore() != null; } public void init() throws IOException { @@ -174,7 +202,7 @@ public class Manager implements Signal { migrateLegacyConfigs(); - accountManager = new SignalServiceAccountManager(BaseConfig.serviceConfiguration, username, account.getPassword(), account.getDeviceId(), BaseConfig.USER_AGENT, timer); + accountManager = getSignalServiceAccountManager(); try { if (account.isRegistered() && accountManager.getPreKeysCount() < BaseConfig.PREKEY_MINIMUM_COUNT) { refreshPreKeys(); @@ -182,6 +210,7 @@ public class Manager implements Signal { } } catch (AuthorizationFailedException e) { System.err.println("Authorization failed, was the number registered elsewhere?"); + throw e; } } @@ -207,6 +236,7 @@ public class Manager implements Signal { if (account.getProfileKey() == null) { // Old config file, creating new profile key account.setProfileKey(KeyUtils.createProfileKey()); + account.save(); } } @@ -216,7 +246,7 @@ public class Manager implements Signal { if (username == null) { account = SignalAccount.createTemporaryAccount(identityKey, registrationId); } else { - byte[] profileKey = KeyUtils.createProfileKey(); + ProfileKey profileKey = KeyUtils.createProfileKey(); account = SignalAccount.create(dataPath, username, identityKey, registrationId, profileKey); account.save(); } @@ -231,42 +261,55 @@ public class Manager implements Signal { createNewIdentity(); } account.setPassword(KeyUtils.createPassword()); - accountManager = new SignalServiceAccountManager(BaseConfig.serviceConfiguration, account.getUsername(), account.getPassword(), BaseConfig.USER_AGENT, timer); + accountManager = getSignalServiceAccountManager(); - if (voiceVerification) - accountManager.requestVoiceVerificationCode(); - else - accountManager.requestSmsVerificationCode(); + if (voiceVerification) { + accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.absent(), Optional.absent()); + } else { + accountManager.requestSmsVerificationCode(false, Optional.absent(), 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(), getSelfUnidentifiedAccessKey(), false, capabilities); + } + + public void setProfileName(String name) throws IOException { + accountManager.setProfileName(account.getProfileKey(), name); + } + + public void setProfileAvatar(File avatar) throws IOException { + final StreamDetails streamDetails = Utils.createStreamDetailsFromFile(avatar); + accountManager.setProfileAvatar(account.getProfileKey(), streamDetails); + streamDetails.getStream().close(); + } + + public void removeProfileAvatar() throws IOException { + accountManager.setProfileAvatar(account.getProfileKey(), null); } 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()); + accountManager.setGcmId(Optional.absent()); + + account.setRegistered(false); + account.save(); } - public URI getDeviceLinkUri() throws TimeoutException, IOException { + 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); + accountManager = getSignalServiceAccountManager(); String uuid = accountManager.getNewDeviceUuid(); - try { - return new URI("tsdevice:/?uuid=" + URLEncoder.encode(uuid, "utf-8") + "&pub_key=" + URLEncoder.encode(Base64.encodeBytesWithoutPadding(getIdentity().serialize()), "utf-8")); - } catch (URISyntaxException e) { - // Shouldn't happen - return null; - } + return Utils.createDeviceLinkUri(new Utils.DeviceLinkInfo(uuid, getIdentity().getPublicKey())); } public void finishDeviceLink(String deviceName) throws IOException, InvalidKeyException, TimeoutException, UserAlreadyExists { @@ -280,9 +323,16 @@ public class Manager implements Signal { } // Create new account with the synced identity - byte[] profileKey = ret.getProfileKey(); - if (profileKey == null) { + byte[] profileKeyBytes = ret.getProfileKey(); + ProfileKey profileKey; + if (profileKeyBytes == null) { profileKey = KeyUtils.createProfileKey(); + } else { + try { + profileKey = new ProfileKey(profileKeyBytes); + } catch (InvalidInputException e) { + throw new IOException("Received invalid profileKey", e); + } } account = SignalAccount.createLinkedAccount(dataPath, username, account.getPassword(), ret.getDeviceId(), ret.getIdentity(), account.getSignalProtocolStore().getLocalRegistrationId(), account.getSignalingKey(), profileKey); @@ -290,6 +340,8 @@ public class Manager implements Signal { requestSyncGroups(); requestSyncContacts(); + requestSyncBlocked(); + requestSyncConfiguration(); account.save(); } @@ -297,33 +349,30 @@ public class Manager implements Signal { public List getLinkedDevices() throws IOException { List devices = accountManager.getDevices(); account.setMultiDevice(devices.size() > 1); + account.save(); return devices; } public void removeLinkedDevices(int deviceId) throws IOException { accountManager.removeDevice(deviceId); + List devices = accountManager.getDevices(); + account.setMultiDevice(devices.size() > 1); + account.save(); } public void addDeviceLink(URI linkUri) throws IOException, InvalidKeyException { - Map query = Util.getQueryMap(linkUri.getRawQuery()); - String deviceIdentifier = query.get("uuid"); - String publicKeyEncoded = query.get("pub_key"); - - if (TextUtils.isEmpty(deviceIdentifier) || TextUtils.isEmpty(publicKeyEncoded)) { - throw new RuntimeException("Invalid device link uri"); - } - - ECPublicKey deviceKey = Curve.decodePoint(Base64.decode(publicKeyEncoded), 0); + Utils.DeviceLinkInfo info = Utils.parseDeviceLinkUri(linkUri); - addDevice(deviceIdentifier, deviceKey); + addDevice(info.deviceIdentifier, info.deviceKey); } private void addDevice(String deviceIdentifier, ECPublicKey deviceKey) throws IOException, InvalidKeyException { IdentityKeyPair identityKeyPair = account.getSignalProtocolStore().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() { @@ -362,7 +411,8 @@ public class Manager implements Signal { public void verifyAccount(String verificationCode, String pin) throws IOException { verificationCode = verificationCode.replace("-", ""); account.setSignalingKey(KeyUtils.createSignalingKey()); - accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, getSelfUnidentifiedAccessKey(), false); + // TODO make unrestricted unidentified access configurable + accountManager.verifyAccountWithCode(verificationCode, account.getSignalingKey(), account.getSignalProtocolStore().getLocalRegistrationId(), true, pin, null, getSelfUnidentifiedAccessKey(), false, capabilities); //accountManager.setGcmId(Optional.of(GoogleCloudMessaging.getInstance(this).register(REGISTRATION_ID))); account.setRegistered(true); @@ -373,12 +423,14 @@ public class Manager implements Signal { } 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.removeV1Pin(); } + account.save(); } private void refreshPreKeys() throws IOException { @@ -389,13 +441,41 @@ public class Manager implements Signal { accountManager.setPreKeys(getIdentity(), signedPreKeyRecord, oneTimePreKeys); } + private SignalServiceMessageReceiver getMessageReceiver() { + return new SignalServiceMessageReceiver(BaseConfig.serviceConfiguration, null, username, account.getPassword(), account.getDeviceId(), account.getSignalingKey(), BaseConfig.USER_AGENT, null, timer); + } + + private SignalServiceMessageSender getMessageSender() { + return new SignalServiceMessageSender(BaseConfig.serviceConfiguration, null, username, account.getPassword(), + account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent()); + } + + private SignalServiceProfile getRecipientProfile(SignalServiceAddress address, Optional unidentifiedAccess) throws IOException { + SignalServiceMessagePipe pipe = unidentifiedMessagePipe != null && unidentifiedAccess.isPresent() ? unidentifiedMessagePipe + : messagePipe; + + if (pipe != null) { + try { + return pipe.getProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile(); + } catch (IOException ignored) { + } + } + + SignalServiceMessageReceiver receiver = getMessageReceiver(); + try { + return receiver.retrieveProfile(address, Optional.absent(), unidentifiedAccess, SignalServiceProfile.RequestType.PROFILE).getProfile(); + } catch (VerificationFailedException e) { + throw new AssertionError(e); + } + } + private Optional createGroupAvatarAttachment(byte[] groupId) throws IOException { File file = getGroupAvatarFile(groupId); if (!file.exists()) { return Optional.absent(); } - return Optional.of(createAttachment(file)); + return Optional.of(Utils.createAttachment(file)); } private Optional createContactAvatarAttachment(String number) throws IOException { @@ -404,7 +484,7 @@ public class Manager implements Signal { return Optional.absent(); } - return Optional.of(createAttachment(file)); + return Optional.of(Utils.createAttachment(file)); } private GroupInfo getGroupForSending(byte[] groupId) throws GroupNotFoundException, NotAGroupMemberException { @@ -430,7 +510,7 @@ public class Manager implements Signal { throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException { final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); if (attachments != null) { - messageBuilder.withAttachments(getSignalServiceAttachments(attachments)); + messageBuilder.withAttachments(Utils.getSignalServiceAttachments(attachments)); } if (groupId != null) { SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER) @@ -451,6 +531,26 @@ public class Manager implements Signal { sendMessageLegacy(messageBuilder, membersSend); } + public void sendGroupMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor, + long targetSentTimestamp, byte[] groupId) + throws IOException, EncapsulatedExceptions, AttachmentInvalidException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp); + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withReaction(reaction) + .withProfileKey(account.getProfileKey().serialize()); + if (groupId != null) { + SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER) + .withId(groupId) + .build(); + messageBuilder.asGroupMessage(group); + } + final GroupInfo g = getGroupForSending(groupId); + // Don't send group message to ourself + final List membersSend = new ArrayList<>(g.members); + membersSend.remove(this.username); + sendMessageLegacy(messageBuilder, membersSend); + } + public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions { SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT) .withId(groupId) @@ -484,7 +584,7 @@ public class Manager implements Signal { Set newMembers = new HashSet<>(); for (String member : members) { try { - member = canonicalizeNumber(member); + member = Utils.canonicalizeNumber(member, username); } catch (InvalidNumberException e) { System.err.println("Failed to add member \"" + member + "\" to group: " + e.getMessage()); System.err.println("Aborting…"); @@ -547,19 +647,26 @@ public class Manager implements Signal { 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()) { try { - group.withAvatar(createAttachment(aFile)); + group.withAvatar(Utils.createAttachment(aFile)); } catch (IOException e) { throw new AttachmentInvalidException(aFile.toString(), e); } } - return SignalServiceDataMessage.newBuilder() + SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() .asGroupMessage(group.build()); + + ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(g.groupId)); + if (thread != null) { + messageBuilder.withExpiration(thread.messageExpirationTime); + } + + return messageBuilder; } private void sendGroupInfoRequest(byte[] groupId, String recipient) throws IOException, EncapsulatedExceptions { @@ -573,6 +680,11 @@ public class Manager implements Signal { SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() .asGroupMessage(group.build()); + ThreadInfo thread = account.getThreadStore().getThread(Base64.encodeBytes(groupId)); + if (thread != null) { + messageBuilder.withExpiration(thread.messageExpirationTime); + } + // Send group info request message to the recipient who sent us a message with this groupId final List membersSend = new ArrayList<>(); membersSend.add(recipient); @@ -593,8 +705,32 @@ public class Manager implements Signal { throws IOException, EncapsulatedExceptions, AttachmentInvalidException { final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText); if (attachments != null) { - messageBuilder.withAttachments(getSignalServiceAttachments(attachments)); + List attachmentStreams = Utils.getSignalServiceAttachments(attachments); + + // Upload attachments here, so we only upload once even for multiple recipients + SignalServiceMessageSender messageSender = getMessageSender(); + 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); } + messageBuilder.withProfileKey(account.getProfileKey().serialize()); + sendMessageLegacy(messageBuilder, recipients); + } + + public void sendMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor, + long targetSentTimestamp, List recipients) + throws IOException, EncapsulatedExceptions, AttachmentInvalidException { + SignalServiceDataMessage.Reaction reaction = new SignalServiceDataMessage.Reaction(emoji, remove, targetAuthor, targetSentTimestamp); + final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder() + .withReaction(reaction) + .withProfileKey(account.getProfileKey().serialize()); sendMessageLegacy(messageBuilder, recipients); } @@ -607,8 +743,9 @@ public class Manager implements Signal { } @Override - public String getContactName(String number) { - ContactInfo contact = account.getContactStore().getContact(number); + public String getContactName(String number) throws InvalidNumberException { + String canonicalizedNumber = Utils.canonicalizeNumber(number, username); + ContactInfo contact = account.getContactStore().getContact(canonicalizedNumber); if (contact == null) { return ""; } else { @@ -617,20 +754,50 @@ public class Manager implements Signal { } @Override - public void setContactName(String number, String name) { + public void setContactName(String number, String name) throws InvalidNumberException { + String canonicalizedNumber = Utils.canonicalizeNumber(number, username); + ContactInfo contact = account.getContactStore().getContact(canonicalizedNumber); + if (contact == null) { + contact = new ContactInfo(); + contact.number = canonicalizedNumber; + System.err.println("Add contact " + canonicalizedNumber + " named " + name); + } else { + System.err.println("Updating contact " + canonicalizedNumber + " name " + contact.name + " -> " + name); + } + contact.name = name; + account.getContactStore().updateContact(contact); + account.save(); + } + + @Override + public void setContactBlocked(String number, boolean blocked) throws InvalidNumberException { + number = Utils.canonicalizeNumber(number, username); ContactInfo contact = account.getContactStore().getContact(number); if (contact == null) { contact = new ContactInfo(); contact.number = number; - System.err.println("Add contact " + number + " named " + name); + System.err.println("Adding and " + (blocked ? "blocking" : "unblocking") + " contact " + number); } else { - System.err.println("Updating contact " + number + " name " + contact.name + " -> " + name); + System.err.println((blocked ? "Blocking" : "Unblocking") + " contact " + number); } - contact.name = name; + contact.blocked = blocked; account.getContactStore().updateContact(contact); account.save(); } + @Override + public void setGroupBlocked(final byte[] groupId, final boolean blocked) throws GroupNotFoundException { + GroupInfo group = getGroup(groupId); + if (group == null) { + throw new GroupNotFoundException(groupId); + } else { + System.err.println((blocked ? "Blocking" : "Unblocking") + " group " + Base64.encodeBytes(groupId)); + group.blocked = blocked; + account.getGroupStore().updateGroup(group); + account.save(); + } + } + @Override public List getGroupIds() { List groups = getGroups(); @@ -730,41 +897,107 @@ public class Manager implements Signal { } } + private byte[] getSenderCertificate() throws IOException { + byte[] certificate = accountManager.getSenderCertificate(); + // TODO cache for a day + return certificate; + } + private byte[] getSelfUnidentifiedAccessKey() { return UnidentifiedAccess.deriveAccessKeyFrom(account.getProfileKey()); } - private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) { - // TODO implement - return null; + private static SignalProfile decryptProfile(SignalServiceProfile encryptedProfile, ProfileKey profileKey) throws IOException { + ProfileCipher profileCipher = new ProfileCipher(profileKey); + try { + return new SignalProfile( + encryptedProfile.getIdentityKey(), + encryptedProfile.getName() == null ? null : new String(profileCipher.decryptName(Base64.decode(encryptedProfile.getName()))), + encryptedProfile.getAvatar(), + encryptedProfile.getUnidentifiedAccess() == null || !profileCipher.verifyUnidentifiedAccess(Base64.decode(encryptedProfile.getUnidentifiedAccess())) ? null : encryptedProfile.getUnidentifiedAccess(), + encryptedProfile.isUnrestrictedUnidentifiedAccess() + ); + } catch (InvalidCiphertextException e) { + return null; + } } - private Optional getAccessForSync() { - // TODO implement - return Optional.absent(); + private byte[] getTargetUnidentifiedAccessKey(SignalServiceAddress recipient) throws IOException { + ContactInfo contact = account.getContactStore().getContact(recipient.getNumber().get()); + if (contact == null || contact.profileKey == null) { + return null; + } + ProfileKey theirProfileKey; + try { + theirProfileKey = new ProfileKey(Base64.decode(contact.profileKey)); + } catch (InvalidInputException e) { + throw new AssertionError(e); + } + SignalProfile targetProfile = decryptProfile(getRecipientProfile(recipient, Optional.absent()), theirProfileKey); + + if (targetProfile == null || targetProfile.getUnidentifiedAccess() == null) { + return null; + } + + if (targetProfile.isUnrestrictedUnidentifiedAccess()) { + return KeyUtils.createUnrestrictedUnidentifiedAccess(); + } + + return UnidentifiedAccess.deriveAccessKeyFrom(theirProfileKey); } - private List> getAccessFor(Collection recipients) { + private Optional getAccessForSync() throws IOException { + byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey(); + byte[] selfUnidentifiedAccessCertificate = getSenderCertificate(); + + if (selfUnidentifiedAccessKey == null || selfUnidentifiedAccessCertificate == null) { + return Optional.absent(); + } + + try { + return Optional.of(new UnidentifiedAccessPair( + new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate), + new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate) + )); + } catch (InvalidCertificateException e) { + return Optional.absent(); + } + } + + private List> getAccessFor(Collection recipients) throws IOException { List> result = new ArrayList<>(recipients.size()); for (SignalServiceAddress recipient : recipients) { - result.add(Optional.absent()); + result.add(getAccessFor(recipient)); } return result; } - private Optional getAccessFor(SignalServiceAddress recipient) { - // TODO implement - return Optional.absent(); + private Optional getAccessFor(SignalServiceAddress recipient) throws IOException { + byte[] recipientUnidentifiedAccessKey = getTargetUnidentifiedAccessKey(recipient); + byte[] selfUnidentifiedAccessKey = getSelfUnidentifiedAccessKey(); + byte[] selfUnidentifiedAccessCertificate = getSenderCertificate(); + + if (recipientUnidentifiedAccessKey == null || selfUnidentifiedAccessKey == null || selfUnidentifiedAccessCertificate == null) { + return Optional.absent(); + } + + try { + return Optional.of(new UnidentifiedAccessPair( + new UnidentifiedAccess(recipientUnidentifiedAccessKey, selfUnidentifiedAccessCertificate), + new UnidentifiedAccess(selfUnidentifiedAccessKey, selfUnidentifiedAccessCertificate) + )); + } catch (InvalidCertificateException e) { + return Optional.absent(); + } } 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()); + SignalServiceMessageSender messageSender = getMessageSender(); try { messageSender.sendMessage(message, getAccessForSync()); } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); throw e; } } @@ -782,11 +1015,11 @@ public class Manager implements Signal { for (SendMessageResult result : results) { if (result.isUnregisteredFailure()) { - unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getNumber(), null)); + unregisteredUsers.add(new UnregisteredUserException(result.getAddress().getNumber().get(), null)); } else if (result.isNetworkFailure()) { - networkExceptions.add(new NetworkFailureException(result.getAddress().getNumber(), null)); + networkExceptions.add(new NetworkFailureException(result.getAddress().getNumber().get(), null)); } else if (result.getIdentityFailure() != null) { - untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getNumber(), result.getIdentityFailure().getIdentityKey())); + untrustedIdentities.add(new UntrustedIdentityException("Untrusted", result.getAddress().getNumber().get(), result.getIdentityFailure().getIdentityKey())); } } if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) { @@ -796,33 +1029,61 @@ public class Manager implements Signal { private List sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection recipients) throws IOException { - Set recipientsTS = getSignalServiceAddresses(recipients); - if (recipientsTS == null) return Collections.emptyList(); + Set recipientsTS = Utils.getSignalServiceAddresses(recipients, username); + if (recipientsTS == null) { + account.save(); + return Collections.emptyList(); + } + if (messagePipe == null) { + messagePipe = getMessageReceiver().createMessagePipe(); + } + if (unidentifiedMessagePipe == null) { + unidentifiedMessagePipe = getMessageReceiver().createUnidentifiedMessagePipe(); + } 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()); + SignalServiceMessageSender messageSender = getMessageSender(); message = messageBuilder.build(); if (message.getGroupInfo().isPresent()) { try { - List result = messageSender.sendMessage(new ArrayList<>(recipientsTS), getAccessFor(recipientsTS), message); + final boolean isRecipientUpdate = false; + List result = messageSender.sendMessage(new ArrayList<>(recipientsTS), getAccessFor(recipientsTS), 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().getNumber().get(), r.getIdentityFailure().getIdentityKey(), TrustLevel.UNTRUSTED); } } return result; } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); return Collections.emptyList(); } + } else if (recipientsTS.size() == 1 && recipientsTS.contains(getSelfAddress())) { + SignalServiceAddress recipient = getSelfAddress(); + final Optional unidentifiedAccess = getAccessFor(recipient); + SentTranscriptMessage transcript = new SentTranscriptMessage(Optional.of(recipient), + message.getTimestamp(), + message, + message.getExpiresInSeconds(), + Collections.singletonMap(recipient, unidentifiedAccess.isPresent()), + false); + SignalServiceSyncMessage syncMessage = SignalServiceSyncMessage.forSentTranscript(transcript); + + List results = new ArrayList<>(recipientsTS.size()); + try { + messageSender.sendMessage(syncMessage, unidentifiedAccess); + } catch (UntrustedIdentityException e) { + account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + results.add(SendMessageResult.identityFailure(recipient, e.getIdentityKey())); + } + return results; } else { // Send to all individually, so sync messages are sent correctly List results = new ArrayList<>(recipientsTS.size()); for (SignalServiceAddress address : recipientsTS) { - ThreadInfo thread = account.getThreadStore().getThread(address.getNumber()); + ThreadInfo thread = account.getThreadStore().getThread(address.getNumber().get()); if (thread != null) { messageBuilder.withExpiration(thread.messageExpirationTime); } else { @@ -833,7 +1094,7 @@ public class Manager implements Signal { SendMessageResult result = messageSender.sendMessage(address, getAccessFor(address), message); results.add(result); } catch (UntrustedIdentityException e) { - account.getSignalProtocolStore().saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED); + account.getSignalProtocolStore().saveIdentity(e.getIdentifier(), e.getIdentityKey(), TrustLevel.UNTRUSTED); results.add(SendMessageResult.identityFailure(address, e.getIdentityKey())); } } @@ -842,30 +1103,15 @@ public class Manager implements Signal { } finally { if (message != null && message.isEndSession()) { for (SignalServiceAddress recipient : recipientsTS) { - handleEndSession(recipient.getNumber()); + handleEndSession(recipient.getNumber().get()); } } account.save(); } } - private Set getSignalServiceAddresses(Collection recipients) { - Set recipientsTS = new HashSet<>(recipients.size()); - for (String recipient : recipients) { - try { - recipientsTS.add(getPushAddress(recipient)); - } catch (InvalidNumberException e) { - System.err.println("Failed to add recipient \"" + recipient + "\": " + e.getMessage()); - System.err.println("Aborting sending."); - account.save(); - return null; - } - } - return recipientsTS; - } - - 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(), getCertificateValidator()); + private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws InvalidMetadataMessageException, ProtocolInvalidMessageException, ProtocolDuplicateMessageException, ProtocolLegacyMessageException, ProtocolInvalidKeyIdException, InvalidMetadataVersionException, ProtocolInvalidVersionException, ProtocolNoSessionException, ProtocolInvalidKeyException, ProtocolUntrustedIdentityException, SelfSendException, UnsupportedDataMessageException { + SignalServiceCipher cipher = new SignalServiceCipher(getSelfAddress(), account.getSignalProtocolStore(), Utils.getCertificateValidator()); try { return cipher.decrypt(envelope); } catch (ProtocolUntrustedIdentityException e) { @@ -879,7 +1125,7 @@ public class Manager implements Signal { account.getSignalProtocolStore().deleteAllSessions(source); } - private void handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, String source, String destination, boolean ignoreAttachments) { + private void handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, String source, SignalServiceAddress destination, boolean ignoreAttachments) { String threadId; if (message.getGroupInfo().isPresent()) { SignalServiceGroup groupInfo = message.getGroupInfo().get(); @@ -907,7 +1153,7 @@ public class Manager implements Signal { } if (groupInfo.getMembers().isPresent()) { - group.members.addAll(groupInfo.getMembers().get()); + group.addMembers(groupInfo.getMembers().get()); } account.getGroupStore().updateGroup(group); @@ -947,13 +1193,13 @@ public class Manager implements Signal { } } else { if (isSync) { - threadId = destination; + threadId = destination.getNumber().get(); } else { threadId = source; } } if (message.isEndSession()) { - handleEndSession(isSync ? destination : source); + handleEndSession(isSync ? destination.getNumber().get() : source); } if (message.isExpirationUpdate() || message.getBody().isPresent()) { ThreadInfo thread = account.getThreadStore().getThread(threadId); @@ -978,12 +1224,32 @@ public class Manager implements Signal { } } if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) { + if (source.equals(username)) { + try { + this.account.setProfileKey(new ProfileKey(message.getProfileKey().get())); + } catch (InvalidInputException ignored) { + } + } ContactInfo contact = account.getContactStore().getContact(source); if (contact == null) { contact = new ContactInfo(); contact.number = source; } contact.profileKey = Base64.encodeBytes(message.getProfileKey().get()); + account.getContactStore().updateContact(contact); + } + 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 e) { + System.err.println("Failed to retrieve attachment (" + attachment.getId() + "): " + e.getMessage()); + } + } + } } } @@ -1003,7 +1269,7 @@ public class Manager implements Signal { } SignalServiceEnvelope envelope; try { - envelope = loadEnvelope(fileEntry); + envelope = Utils.loadEnvelope(fileEntry); if (envelope == null) { continue; } @@ -1035,7 +1301,7 @@ public class Manager implements Signal { 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); + final SignalServiceMessageReceiver messageReceiver = getMessageReceiver(); try { if (messagePipe == null) { @@ -1048,16 +1314,13 @@ public class Manager implements Signal { 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 - try { - File cacheFile = getMessageCacheFile(envelope.getSource(), now, envelope.getTimestamp()); - storeEnvelope(envelope, cacheFile); - } catch (IOException e) { - System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage()); - } + envelope = messagePipe.read(timeout, unit, envelope1 -> { + // store message on disk, before acknowledging receipt to the server + try { + File cacheFile = getMessageCacheFile(envelope1.getSourceE164().get(), now, envelope1.getTimestamp()); + Utils.storeEnvelope(envelope1, cacheFile); + } catch (IOException e) { + System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage()); } }); } catch (TimeoutException e) { @@ -1077,11 +1340,13 @@ public class Manager implements Signal { handleMessage(envelope, content, ignoreAttachments); } account.save(); - handler.handleMessage(envelope, content, exception); + if (!isMessageBlocked(envelope, content)) { + handler.handleMessage(envelope, content, exception); + } if (!(exception instanceof ProtocolUntrustedIdentityException)) { File cacheFile = null; try { - cacheFile = getMessageCacheFile(envelope.getSource(), now, envelope.getTimestamp()); + cacheFile = getMessageCacheFile(envelope.getSourceE164().get(), now, envelope.getTimestamp()); Files.delete(cacheFile.toPath()); // Try to delete directory if empty new File(getMessageCachePath()).delete(); @@ -1098,18 +1363,51 @@ public class Manager implements Signal { } } + 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 = getContact(source.getNumber().get()); + if (sourceContact != null && sourceContact.blocked) { + return true; + } + + if (content != null && content.getDataMessage().isPresent()) { + SignalServiceDataMessage message = content.getDataMessage().get(); + if (message.getGroupInfo().isPresent()) { + SignalServiceGroup groupInfo = message.getGroupInfo().get(); + GroupInfo group = getGroup(groupInfo.getGroupId()); + if (groupInfo.getType() == SignalServiceGroup.Type.DELIVER && group != null && group.blocked) { + return true; + } + } + } + return false; + } + private void handleMessage(SignalServiceEnvelope envelope, SignalServiceContent content, boolean ignoreAttachments) { if (content != null) { + SignalServiceAddress sender; + if (!envelope.isUnidentifiedSender() && envelope.hasSource()) { + sender = envelope.getSourceAddress(); + } else { + sender = content.getSender(); + } if (content.getDataMessage().isPresent()) { SignalServiceDataMessage message = content.getDataMessage().get(); - handleSignalServiceDataMessage(message, false, envelope.getSource(), username, ignoreAttachments); + handleSignalServiceDataMessage(message, false, sender.getNumber().get(), 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(); + handleSignalServiceDataMessage(message.getMessage(), true, sender.getNumber().get(), message.getDestination().orNull(), ignoreAttachments); } if (syncMessage.getRequest().isPresent()) { RequestMessage rm = syncMessage.getRequest().get(); @@ -1127,7 +1425,14 @@ public class Manager implements Signal { e.printStackTrace(); } } - // TODO Handle rm.isBlockedListRequest(); rm.isConfigurationRequest(); + if (rm.isBlockedListRequest()) { + try { + sendBlockedList(); + } catch (UntrustedIdentityException | IOException e) { + e.printStackTrace(); + } + } + // TODO Handle rm.isConfigurationRequest(); } if (syncMessage.getGroups().isPresent()) { File tmpFile = null; @@ -1144,8 +1449,11 @@ public class Manager implements Signal { if (g.getName().isPresent()) { syncGroup.name = g.getName().get(); } - syncGroup.members.addAll(g.getMembers()); - syncGroup.active = g.isActive(); + syncGroup.addMembers(g.getMembers()); + if (!g.isActive()) { + syncGroup.members.remove(username); + } + syncGroup.blocked = g.isBlocked(); if (g.getColor().isPresent()) { syncGroup.color = g.getColor().get(); } @@ -1153,6 +1461,8 @@ public class Manager implements Signal { if (g.getAvatar().isPresent()) { retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId); } + syncGroup.inboxPosition = g.getInboxPosition().orNull(); + syncGroup.archived = g.isArchived(); account.getGroupStore().updateGroup(syncGroup); } } @@ -1169,7 +1479,23 @@ public class Manager implements Signal { } } if (syncMessage.getBlockedList().isPresent()) { - // TODO store list of blocked numbers + final BlockedListMessage blockedListMessage = syncMessage.getBlockedList().get(); + for (SignalServiceAddress address : blockedListMessage.getAddresses()) { + if (address.getNumber().isPresent()) { + try { + setContactBlocked(address.getNumber().get(), true); + } catch (InvalidNumberException e) { + e.printStackTrace(); + } + } + } + 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; @@ -1183,13 +1509,13 @@ public class Manager implements Signal { } 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()); + ContactInfo contact = account.getContactStore().getContact(c.getAddress().getNumber().get()); if (contact == null) { contact = new ContactInfo(); - contact.number = c.getNumber(); + contact.number = c.getAddress().getNumber().get(); } if (c.getName().isPresent()) { contact.name = c.getName().get(); @@ -1198,20 +1524,24 @@ public class Manager implements Signal { contact.color = c.getColor().get(); } if (c.getProfileKey().isPresent()) { - contact.profileKey = Base64.encodeBytes(c.getProfileKey().get()); + contact.profileKey = Base64.encodeBytes(c.getProfileKey().get().serialize()); } if (c.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = c.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination().getNumber().get(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); } if (c.getExpirationTimer().isPresent()) { - ThreadInfo thread = account.getThreadStore().getThread(c.getNumber()); + ThreadInfo thread = account.getThreadStore().getThread(c.getAddress().getNumber().get()); + if (thread == null) { + thread = new ThreadInfo(); + thread.id = c.getAddress().getNumber().get(); + } thread.messageExpirationTime = c.getExpirationTimer().get(); account.getThreadStore().updateThread(thread); } - if (c.isBlocked()) { - // TODO store list of blocked numbers - } + contact.blocked = c.isBlocked(); + contact.inboxPosition = c.getInboxPosition().orNull(); + contact.archived = c.isArchived(); account.getContactStore().updateContact(contact); if (c.getAvatar().isPresent()) { @@ -1233,7 +1563,7 @@ public class Manager implements Signal { } if (syncMessage.getVerified().isPresent()) { final VerifiedMessage verifiedMessage = syncMessage.getVerified().get(); - account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); + account.getSignalProtocolStore().saveIdentity(verifiedMessage.getDestination().getNumber().get(), verifiedMessage.getIdentityKey(), TrustLevel.fromVerifiedState(verifiedMessage.getVerified())); } if (syncMessage.getConfiguration().isPresent()) { // TODO @@ -1242,73 +1572,6 @@ public class Manager implements Signal { } } - private SignalServiceEnvelope loadEnvelope(File file) throws IOException { - try (FileInputStream f = new FileInputStream(file)) { - DataInputStream in = new DataInputStream(f); - int version = in.readInt(); - if (version > 2) { - return null; - } - int type = in.readInt(); - String source = in.readUTF(); - int sourceDevice = in.readInt(); - if (version == 1) { - // read legacy relay field - in.readUTF(); - } - long timestamp = in.readLong(); - byte[] content = null; - int contentLen = in.readInt(); - if (contentLen > 0) { - content = new byte[contentLen]; - in.readFully(content); - } - byte[] legacyMessage = null; - int legacyMessageLen = in.readInt(); - if (legacyMessageLen > 0) { - legacyMessage = new byte[legacyMessageLen]; - in.readFully(legacyMessage); - } - long serverTimestamp = 0; - String uuid = null; - if (version == 2) { - serverTimestamp = in.readLong(); - uuid = in.readUTF(); - if ("".equals(uuid)) { - uuid = null; - } - } - return new SignalServiceEnvelope(type, source, sourceDevice, timestamp, legacyMessage, content, serverTimestamp, uuid); - } - } - - private void storeEnvelope(SignalServiceEnvelope envelope, File file) throws IOException { - try (FileOutputStream f = new FileOutputStream(file)) { - try (DataOutputStream out = new DataOutputStream(f)) { - out.writeInt(2); // version - out.writeInt(envelope.getType()); - out.writeUTF(envelope.getSource()); - out.writeInt(envelope.getSourceDevice()); - out.writeLong(envelope.getTimestamp()); - if (envelope.hasContent()) { - out.writeInt(envelope.getContent().length); - out.write(envelope.getContent()); - } else { - out.writeInt(0); - } - if (envelope.hasLegacyMessage()) { - out.writeInt(envelope.getLegacyMessage().length); - out.write(envelope.getLegacyMessage()); - } else { - out.writeInt(0); - } - out.writeLong(envelope.getServerTimestamp()); - String uuid = envelope.getUuid(); - out.writeUTF(uuid == null ? "" : uuid); - } - } - } - private File getContactAvatarFile(String number) { return new File(avatarsPath, "contact-" + number); } @@ -1320,7 +1583,7 @@ public class Manager implements Signal { return retrieveAttachment(pointer, getContactAvatarFile(number), false); } else { SignalServiceAttachmentStream stream = attachment.asStream(); - return retrieveAttachment(stream, getContactAvatarFile(number)); + return Utils.retrieveAttachment(stream, getContactAvatarFile(number)); } } @@ -1335,7 +1598,7 @@ public class Manager implements Signal { return retrieveAttachment(pointer, getGroupAvatarFile(groupId), false); } else { SignalServiceAttachmentStream stream = attachment.asStream(); - return retrieveAttachment(stream, getGroupAvatarFile(groupId)); + return Utils.retrieveAttachment(stream, getGroupAvatarFile(groupId)); } } @@ -1348,23 +1611,6 @@ public class Manager implements Signal { return retrieveAttachment(pointer, getAttachmentFile(pointer.getId()), true); } - private File retrieveAttachment(SignalServiceAttachmentStream stream, File outputFile) throws IOException { - InputStream input = stream.getInputStream(); - - 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; - } - return outputFile; - } - private File retrieveAttachment(SignalServiceAttachmentPointer pointer, File outputFile, boolean storePreview) throws IOException, InvalidMessageException { if (storePreview && pointer.getPreview().isPresent()) { File previewFile = new File(outputFile + ".preview"); @@ -1377,7 +1623,7 @@ 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 = getMessageReceiver(); File tmpFile = IOUtils.createTempFile(); try (InputStream input = messageReceiver.retrieveAttachment(pointer, tmpFile, BaseConfig.MAX_ATTACHMENT_SIZE)) { @@ -1403,20 +1649,10 @@ public class Manager implements Signal { } 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); + final SignalServiceMessageReceiver messageReceiver = getMessageReceiver(); return messageReceiver.retrieveAttachment(pointer, tmpFile, BaseConfig.MAX_ATTACHMENT_SIZE); } - private String canonicalizeNumber(String number) throws InvalidNumberException { - String localNumber = username; - return PhoneNumberFormatter.formatNumber(number, localNumber); - } - - private SignalServiceAddress getPushAddress(String number) throws InvalidNumberException { - String e164number = canonicalizeNumber(number); - return new SignalServiceAddress(e164number); - } - @Override public boolean isRemote() { return false; @@ -1431,9 +1667,9 @@ public class Manager implements Signal { 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)); + new ArrayList<>(record.getMembers()), createGroupAvatarAttachment(record.groupId), + record.members.contains(username), Optional.fromNullable(info != null ? info.messageExpirationTime : null), + Optional.fromNullable(record.color), record.blocked, Optional.fromNullable(record.inboxPosition), record.archived)); } } @@ -1457,7 +1693,7 @@ public class Manager implements Signal { } } - private void sendContacts() throws IOException, UntrustedIdentityException { + public void sendContacts() throws IOException, UntrustedIdentityException { File contactsFile = IOUtils.createTempFile(); try { @@ -1474,25 +1710,29 @@ public class Manager implements Signal { } } if (currentIdentity != null) { - verifiedMessage = new VerifiedMessage(record.number, currentIdentity.getIdentityKey(), currentIdentity.getTrustLevel().toVerifiedState(), currentIdentity.getDateAdded().getTime()); + 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), + ProfileKey profileKey = null; + try { + profileKey = record.profileKey == null ? null : new ProfileKey(Base64.decode(record.profileKey)); + } catch (InvalidInputException ignored) { + } + out.write(new DeviceContact(record.getAddress(), 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))); + Optional.fromNullable(verifiedMessage), Optional.fromNullable(profileKey), record.blocked, + Optional.fromNullable(info != null ? info.messageExpirationTime : null), + 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)); } } @@ -1516,11 +1756,31 @@ public class Manager implements Signal { } } - private void sendVerifiedMessage(String destination, IdentityKey identityKey, TrustLevel trustLevel) throws IOException, UntrustedIdentityException { + private 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.blocked) { + 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); } @@ -1533,8 +1793,9 @@ public class Manager implements Signal { return account.getSignalProtocolStore().getIdentities(); } - public List getIdentities(String number) { - return account.getSignalProtocolStore().getIdentities(number); + public Pair> getIdentities(String number) throws InvalidNumberException { + String canonicalizedNumber = Utils.canonicalizeNumber(number, username); + return new Pair<>(canonicalizedNumber, account.getSignalProtocolStore().getIdentities(canonicalizedNumber)); } /** @@ -1555,7 +1816,7 @@ public class Manager implements Signal { account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); try { - sendVerifiedMessage(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1583,7 +1844,7 @@ public class Manager implements Signal { account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); try { - sendVerifiedMessage(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); + sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1607,7 +1868,7 @@ public class Manager implements Signal { if (id.getTrustLevel() == TrustLevel.UNTRUSTED) { account.getSignalProtocolStore().saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); try { - sendVerifiedMessage(name, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); + sendVerifiedMessage(new SignalServiceAddress(null, name), id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED); } catch (IOException | UntrustedIdentityException e) { e.printStackTrace(); } @@ -1618,8 +1879,7 @@ public class Manager implements Signal { } public String computeSafetyNumber(String theirUsername, IdentityKey theirIdentityKey) { - Fingerprint fingerprint = new NumericFingerprintGenerator(5200).createFor(username, getIdentity(), theirUsername, theirIdentityKey); - return fingerprint.getDisplayableFingerprint().getDisplayText(); + return Utils.computeSafetyNumber(username, getIdentity(), theirUsername, theirIdentityKey); } public interface ReceiveMessageHandler {