*/
package org.asamk.signal.manager;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
import org.asamk.Signal;
import org.asamk.signal.AttachmentInvalidException;
import org.asamk.signal.GroupNotFoundException;
+import org.asamk.signal.JsonStickerPack;
import org.asamk.signal.NotAGroupMemberException;
+import org.asamk.signal.StickerPackInvalidException;
import org.asamk.signal.TrustLevel;
import org.asamk.signal.UserAlreadyExists;
import org.asamk.signal.storage.SignalAccount;
import org.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.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.messages.SignalServiceDataMessage;
import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
import org.whispersystems.signalservice.api.messages.SignalServiceGroup;
+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.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;
import org.whispersystems.signalservice.api.util.UptimeSleepTimer;
import org.whispersystems.signalservice.internal.push.SignalServiceProtos;
import org.whispersystems.signalservice.internal.push.UnsupportedDataMessageException;
+import org.whispersystems.signalservice.internal.util.Hex;
import org.whispersystems.util.Base64;
import java.io.File;
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.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
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;
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();
}
accountManager = getSignalServiceAccountManager();
if (voiceVerification) {
- accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.<String>absent(), Optional.<String>absent());
+ accountManager.requestVoiceVerificationCode(Locale.getDefault(), Optional.absent(), Optional.absent());
} else {
- accountManager.requestSmsVerificationCode(false, Optional.<String>absent(), Optional.<String>absent());
+ accountManager.requestSmsVerificationCode(false, Optional.absent(), Optional.absent());
}
account.setRegistered(false);
}
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 {
// 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.<String>absent());
+ accountManager.setGcmId(Optional.absent());
account.setRegistered(false);
account.save();
}
// 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);
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();
}
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);
+ 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);
}
public void setRegistrationLockPin(Optional<String> 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 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.<SignalServiceMessageSender.EventListener>absent());
+ account.getDeviceId(), account.getSignalProtocolStore(), BaseConfig.USER_AGENT, account.isMultiDevice(), Optional.fromNullable(messagePipe), Optional.fromNullable(unidentifiedMessagePipe), Optional.absent());
+ }
+
+ private SignalServiceProfile getRecipientProfile(SignalServiceAddress address, Optional<UnidentifiedAccess> 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<SignalServiceAttachmentStream> createGroupAvatarAttachment(byte[] groupId) throws IOException {
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<String> 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)
messageBuilder.withAttachments(attachmentPointers);
}
- messageBuilder.withProfileKey(account.getProfileKey());
+ messageBuilder.withProfileKey(account.getProfileKey().serialize());
+ sendMessageLegacy(messageBuilder, recipients);
+ }
+
+ public void sendMessageReaction(String emoji, boolean remove, SignalServiceAddress targetAuthor,
+ long targetSentTimestamp, List<String> 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);
}
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("Adding and " + (blocked ? "blocking" : "unblocking") + " contact " + number);
+ } else {
+ System.err.println((blocked ? "Blocking" : "Unblocking") + " contact " + number);
+ }
+ 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<byte[]> getGroupIds() {
List<GroupInfo> groups = getGroups();
account.getThreadStore().updateThread(thread);
}
+ /**
+ * 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 = getMessageSender();
+
+ byte[] packKey = KeyUtils.createStickerUploadKey();
+ String packId = messageSender.uploadStickerManifest(manifest, packKey);
+
+ try {
+ return new URI("https", "signal.art", "/addstickers/", "pack_id=" + URLEncoder.encode(packId, "utf-8") + "&pack_key=" + URLEncoder.encode(Hex.toStringCondensed(packKey), "utf-8"))
+ .toString();
+ } catch (URISyntaxException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ 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");
+ }
+
+ JsonStickerPack pack = parseStickerPack(rootPath, zip);
+
+ if (pack.stickers == null) {
+ throw new StickerPackInvalidException("Must set a 'stickers' field.");
+ }
+
+ if (pack.stickers.isEmpty()) {
+ throw new StickerPackInvalidException("Must include stickers.");
+ }
+
+ List<StickerInfo> 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<InputStream, Long> data;
+ try {
+ data = getInputStreamAndLength(rootPath, zip, sticker.file);
+ } catch (IOException ignored) {
+ throw new StickerPackInvalidException("Could not find find " + sticker.file);
+ }
+
+ StickerInfo stickerInfo = new StickerInfo(data.first(), data.second(), Optional.fromNullable(sticker.emoji).or(""));
+ 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<InputStream, Long> data;
+ try {
+ data = getInputStreamAndLength(rootPath, zip, pack.cover.file);
+ } catch (IOException ignored) {
+ throw new StickerPackInvalidException("Could not find find " + pack.cover.file);
+ }
+
+ cover = new StickerInfo(data.first(), data.second(), Optional.fromNullable(pack.cover.emoji).or(""));
+ }
+
+ return new SignalServiceStickerManifestUpload(
+ pack.title,
+ pack.author,
+ cover,
+ stickers);
+ }
+
+ private static JsonStickerPack parseStickerPack(String rootPath, ZipFile zip) throws IOException, StickerPackInvalidException {
+ 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<InputStream, Long> 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();
SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
}
}
+ 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 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 Optional<UnidentifiedAccessPair> getAccessForSync() {
- // TODO implement
- return Optional.absent();
+ private Optional<UnidentifiedAccessPair> 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<Optional<UnidentifiedAccessPair>> getAccessFor(Collection<SignalServiceAddress> recipients) {
+ private List<Optional<UnidentifiedAccessPair>> getAccessFor(Collection<SignalServiceAddress> recipients) throws IOException {
List<Optional<UnidentifiedAccessPair>> result = new ArrayList<>(recipients.size());
for (SignalServiceAddress recipient : recipients) {
- result.add(Optional.<UnidentifiedAccessPair>absent());
+ result.add(getAccessFor(recipient));
}
return result;
}
- private Optional<UnidentifiedAccessPair> getAccessFor(SignalServiceAddress recipient) {
- // TODO implement
- return Optional.absent();
+ private Optional<UnidentifiedAccessPair> 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)
return Collections.emptyList();
}
+ if (messagePipe == null) {
+ messagePipe = getMessageReceiver().createMessagePipe();
+ }
+ if (unidentifiedMessagePipe == null) {
+ unidentifiedMessagePipe = getMessageReceiver().createUnidentifiedMessagePipe();
+ }
SignalServiceDataMessage message = null;
try {
SignalServiceMessageSender messageSender = getMessageSender();
}
if (message.getProfileKey().isPresent() && message.getProfileKey().get().length == 32) {
if (source.equals(username)) {
- this.account.setProfileKey(message.getProfileKey().get());
+ try {
+ this.account.setProfileKey(new ProfileKey(message.getProfileKey().get()));
+ } catch (InvalidInputException ignored) {
+ }
}
ContactInfo contact = account.getContactStore().getContact(source);
if (contact == null) {
contact.number = source;
}
contact.profileKey = Base64.encodeBytes(message.getProfileKey().get());
+ account.getContactStore().updateContact(contact);
}
if (message.getPreviews().isPresent()) {
final List<SignalServiceDataMessage.Preview> previews = message.getPreviews().get();
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.getSourceE164().get(), now, envelope.getTimestamp());
- Utils.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) {
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 {
}
}
+ 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;
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;
syncGroup.name = g.getName().get();
}
syncGroup.addMembers(g.getMembers());
- syncGroup.active = g.isActive();
+ if (!g.isActive()) {
+ syncGroup.members.remove(username);
+ }
+ 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 (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;
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();
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()) {
ThreadInfo info = account.getThreadStore().getThread(Base64.encodeBytes(record.groupId));
out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name),
new ArrayList<>(record.getMembers()), createGroupAvatarAttachment(record.groupId),
- record.active, Optional.fromNullable(info != null ? info.messageExpirationTime : null),
- Optional.fromNullable(record.color), false));
+ record.members.contains(username), Optional.fromNullable(info != null ? info.messageExpirationTime : null),
+ Optional.fromNullable(record.color), record.blocked, Optional.fromNullable(record.inboxPosition), record.archived));
}
}
}
}
- byte[] profileKey = record.profileKey == null ? null : Base64.decode(record.profileKey);
- // TODO store list of blocked numbers
- boolean blocked = false;
+ 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.getSelfAddress(),
- Optional.<String>absent(), Optional.<SignalServiceAttachmentStream>absent(),
- Optional.<String>absent(), Optional.<VerifiedMessage>absent(),
+ Optional.absent(), Optional.absent(),
+ Optional.absent(), Optional.absent(),
Optional.of(account.getProfileKey()),
- false, Optional.<Integer>absent()));
+ false, Optional.absent(), Optional.absent(), false));
}
}
}
}
+ private void sendBlockedList() throws IOException, UntrustedIdentityException {
+ List<SignalServiceAddress> addresses = new ArrayList<>();
+ for (ContactInfo record : account.getContactStore().getContacts()) {
+ if (record.blocked) {
+ addresses.add(record.getAddress());
+ }
+ }
+ List<byte[]> 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));
git.nmode.ca / signal-cli / blobdiff
