Fix addDevice

[signal-cli] / src / main / java / org / asamk / signal / Manager.java

diff --git a/src/main/java/org/asamk/signal/Manager.java b/src/main/java/org/asamk/signal/Manager.java
index d442224a854a60680e6f868aab0df0d2da1d225c..3931f3e31928ac5d6513b9e9c0372ed370c0607e 100644 (file)
--- a/src/main/java/org/asamk/signal/Manager.java
+++ b/src/main/java/org/asamk/signal/Manager.java
@@ -23,10 +23,12 @@ import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.node.ObjectNode;

+import org.apache.http.util.TextUtils;

 import org.asamk.Signal;
 import org.whispersystems.libsignal.*;
 import org.whispersystems.libsignal.ecc.Curve;
 import org.whispersystems.libsignal.ecc.ECKeyPair;
 import org.asamk.Signal;
 import org.whispersystems.libsignal.*;
 import org.whispersystems.libsignal.ecc.Curve;
 import org.whispersystems.libsignal.ecc.ECKeyPair;

+import org.whispersystems.libsignal.ecc.ECPublicKey;

 import org.whispersystems.libsignal.state.PreKeyRecord;
 import org.whispersystems.libsignal.state.SignalProtocolStore;
 import org.whispersystems.libsignal.state.SignedPreKeyRecord;
 import org.whispersystems.libsignal.state.PreKeyRecord;
 import org.whispersystems.libsignal.state.SignalProtocolStore;
 import org.whispersystems.libsignal.state.SignedPreKeyRecord;


@@ -37,20 +39,22 @@ 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.SignalServiceMessagePipe;
 import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
 import org.whispersystems.signalservice.api.SignalServiceMessageSender;

-import org.whispersystems.signalservice.api.crypto.*;
+import org.whispersystems.signalservice.api.crypto.SignalServiceCipher;

 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
 import org.whispersystems.signalservice.api.messages.*;
 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
 import org.whispersystems.signalservice.api.messages.*;

-import org.whispersystems.signalservice.api.messages.multidevice.SignalServiceSyncMessage;
+import org.whispersystems.signalservice.api.messages.multidevice.*;

 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.api.push.TrustStore;
 import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException;
 import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.api.push.TrustStore;
 import org.whispersystems.signalservice.api.push.exceptions.AuthorizationFailedException;
 import org.whispersystems.signalservice.api.push.exceptions.EncapsulatedExceptions;
 import org.whispersystems.signalservice.api.util.InvalidNumberException;
 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;

+import org.whispersystems.signalservice.internal.push.SignalServiceProtos;

 
 import java.io.*;
 import java.net.URI;
 import java.net.URISyntaxException;
 
 import java.io.*;
 import java.net.URI;
 import java.net.URISyntaxException;

+import java.net.URLDecoder;

 import java.net.URLEncoder;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.net.URLEncoder;
 import java.nio.file.Files;
 import java.nio.file.Paths;


@@ -75,7 +79,7 @@ class Manager implements Signal {
 
     private final ObjectMapper jsonProcessot = new ObjectMapper();
     private String username;
 
     private final ObjectMapper jsonProcessot = new ObjectMapper();
     private String username;

-    int deviceId = SignalServiceAddress.DEFAULT_DEVICE_ID;
+    private int deviceId = SignalServiceAddress.DEFAULT_DEVICE_ID;

     private String password;
     private String signalingKey;
     private int preKeyIdOffset;
     private String password;
     private String signalingKey;
     private int preKeyIdOffset;


@@ -103,6 +107,10 @@ class Manager implements Signal {
         return username;
     }
 
         return username;
     }
 

+    public int getDeviceId() {
+        return deviceId;
+    }
+

     public String getFileName() {
         new File(dataPath).mkdirs();
         return dataPath + "/" + username;
     public String getFileName() {
         new File(dataPath).mkdirs();
         return dataPath + "/" + username;


@@ -245,6 +253,61 @@ class Manager implements Signal {
 
         registered = true;
         refreshPreKeys();
 
         registered = true;
         refreshPreKeys();

+
+        requestSyncGroups();
+        requestSyncContacts();
+
+        save();
+    }
+
+    public List<DeviceInfo> getLinkedDevices() throws IOException {
+        return accountManager.getDevices();
+    }
+
+    public void removeLinkedDevices(int deviceId) throws IOException {
+        accountManager.removeDevice(deviceId);
+    }
+
+    public static Map<String, String> getQueryMap(String query) {
+        String[] params = query.split("&");
+        Map<String, String> map = new HashMap<>();
+        for (String param : params) {
+            String name = null;
+            try {
+                name = URLDecoder.decode(param.split("=")[0], "utf-8");
+            } catch (UnsupportedEncodingException e) {
+                // Impossible
+            }
+            String value = null;
+            try {
+                value = URLDecoder.decode(param.split("=")[1], "utf-8");
+            } catch (UnsupportedEncodingException e) {
+                // Impossible
+            }
+            map.put(name, value);
+        }
+        return map;
+    }
+
+    public void addDeviceLink(URI linkUri) throws IOException, InvalidKeyException {
+        Map<String, String> query = 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);
+
+        addDevice(deviceIdentifier, deviceKey);
+    }
+
+    private void addDevice(String deviceIdentifier, ECPublicKey deviceKey) throws IOException, InvalidKeyException {
+        IdentityKeyPair identityKeyPair = signalProtocolStore.getIdentityKeyPair();
+        String verificationCode = accountManager.getNewDeviceVerificationCode();
+
+        accountManager.addDevice(deviceIdentifier, deviceKey, identityKeyPair, verificationCode);

     }
 
     private List<PreKeyRecord> generatePreKeys() {
     }
 
     private List<PreKeyRecord> generatePreKeys() {


@@ -335,7 +398,7 @@ class Manager implements Signal {
         return SignalServiceAttachments;
     }
 
         return SignalServiceAttachments;
     }
 

-    private static SignalServiceAttachmentStream createAttachment(String attachment) throws IOException {
+    private static SignalServiceAttachment createAttachment(String attachment) throws IOException {

         File attachmentFile = new File(attachment);
         InputStream attachmentStream = new FileInputStream(attachmentFile);
         final long attachmentSize = attachmentFile.length();
         File attachmentFile = new File(attachment);
         InputStream attachmentStream = new FileInputStream(attachmentFile);
         final long attachmentSize = attachmentFile.length();


@@ -359,7 +422,9 @@ class Manager implements Signal {
         }
         SignalServiceDataMessage message = messageBuilder.build();
 
         }
         SignalServiceDataMessage message = messageBuilder.build();
 

-        sendMessage(message, groupStore.getGroup(groupId).members);
+        Set<String> members = groupStore.getGroup(groupId).members;
+        members.remove(this.username);
+        sendMessage(message, members);

     }
 
     public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, UntrustedIdentityException {
     }
 
     public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions, UntrustedIdentityException {


@@ -371,7 +436,11 @@ class Manager implements Signal {
                 .asGroupMessage(group)
                 .build();
 
                 .asGroupMessage(group)
                 .build();
 

-        sendMessage(message, groupStore.getGroup(groupId).members);
+        final GroupInfo g = groupStore.getGroup(groupId);
+        g.members.remove(this.username);
+        groupStore.updateGroup(g);
+
+        sendMessage(message, g.members);

     }
 
     public byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<String> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, UntrustedIdentityException {
     }
 
     public byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<String> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException, UntrustedIdentityException {


@@ -421,7 +490,9 @@ class Manager implements Signal {
                 .asGroupMessage(group.build())
                 .build();
 
                 .asGroupMessage(group.build())
                 .build();
 

-        sendMessage(message, g.members);
+        final Set<String> membersSend = g.members;
+        membersSend.remove(this.username);
+        sendMessage(message, membersSend);

         return g.groupId;
     }
 
         return g.groupId;
     }
 


@@ -455,38 +526,72 @@ class Manager implements Signal {
         sendMessage(message, recipients);
     }
 
         sendMessage(message, recipients);
     }
 

-    private void sendMessage(SignalServiceDataMessage message, Collection<String> recipients)
+    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));
+        try {
+            sendMessage(message);
+        } catch (EncapsulatedExceptions encapsulatedExceptions) {
+            encapsulatedExceptions.printStackTrace();
+        } catch (UntrustedIdentityException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void requestSyncContacts() throws IOException {
+        SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS).build();
+        SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
+        try {
+            sendMessage(message);
+        } catch (EncapsulatedExceptions encapsulatedExceptions) {
+            encapsulatedExceptions.printStackTrace();
+        } catch (UntrustedIdentityException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void sendMessage(SignalServiceSyncMessage message)

             throws IOException, EncapsulatedExceptions, UntrustedIdentityException {
         SignalServiceMessageSender messageSender = new SignalServiceMessageSender(URL, TRUST_STORE, username, password,
                 deviceId, signalProtocolStore, USER_AGENT, Optional.<SignalServiceMessageSender.EventListener>absent());
             throws IOException, EncapsulatedExceptions, UntrustedIdentityException {
         SignalServiceMessageSender messageSender = new SignalServiceMessageSender(URL, TRUST_STORE, username, password,
                 deviceId, signalProtocolStore, USER_AGENT, Optional.<SignalServiceMessageSender.EventListener>absent());

+        messageSender.sendMessage(message);
+    }

 
 

-        Set<SignalServiceAddress> 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.");
-                save();
-                return;
+    private void sendMessage(SignalServiceDataMessage message, Collection<String> recipients)
+            throws IOException, EncapsulatedExceptions, UntrustedIdentityException {
+        try {
+            SignalServiceMessageSender messageSender = new SignalServiceMessageSender(URL, TRUST_STORE, username, password,
+                    deviceId, signalProtocolStore, USER_AGENT, Optional.<SignalServiceMessageSender.EventListener>absent());
+
+            Set<SignalServiceAddress> 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.");
+                    save();
+                    return;
+                }

             }
             }

-        }

 
 

-        if (message.getGroupInfo().isPresent()) {
-            messageSender.sendMessage(new ArrayList<>(recipientsTS), message);
-        } else {
-            // Send to all individually, so sync messages are sent correctly
-            for (SignalServiceAddress address : recipientsTS) {
-                messageSender.sendMessage(address, message);
+            if (message.getGroupInfo().isPresent()) {
+                messageSender.sendMessage(new ArrayList<>(recipientsTS), message);
+            } else {
+                // Send to all individually, so sync messages are sent correctly
+                for (SignalServiceAddress address : recipientsTS) {
+                    messageSender.sendMessage(address, message);
+                }

             }
             }

-        }

 
 

-        if (message.isEndSession()) {
-            for (SignalServiceAddress recipient : recipientsTS) {
-                handleEndSession(recipient.getNumber());
+            if (message.isEndSession()) {
+                for (SignalServiceAddress recipient : recipientsTS) {
+                    handleEndSession(recipient.getNumber());
+                }

             }
             }

+        } finally {
+            save();

         }
         }

-        save();

     }
 
     private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) {
     }
 
     private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) {


@@ -526,6 +631,7 @@ class Manager implements Signal {
                             long avatarId = avatar.asPointer().getId();
                             try {
                                 retrieveAttachment(avatar.asPointer());
                             long avatarId = avatar.asPointer().getId();
                             try {
                                 retrieveAttachment(avatar.asPointer());

+                                // TODO store group avatar in /avatar/groups folder

                                 group.avatarId = avatarId;
                             } catch (IOException | InvalidMessageException e) {
                                 System.err.println("Failed to retrieve group avatar (" + avatarId + "): " + e.getMessage());
                                 group.avatarId = avatarId;
                             } catch (IOException | InvalidMessageException e) {
                                 System.err.println("Failed to retrieve group avatar (" + avatarId + "): " + e.getMessage());


@@ -553,6 +659,7 @@ class Manager implements Signal {
                     try {
                         group = groupStore.getGroup(groupInfo.getGroupId());
                         group.members.remove(source);
                     try {
                         group = groupStore.getGroup(groupInfo.getGroupId());
                         group.members.remove(source);

+                        groupStore.updateGroup(group);

                     } catch (GroupNotFoundException e) {
                     }
                     break;
                     } catch (GroupNotFoundException e) {
                     }
                     break;


@@ -602,10 +709,68 @@ class Manager implements Signal {
                                     group = handleSignalServiceDataMessage(message, true, envelope.getSource(), syncMessage.getSent().get().getDestination().get());
                                 }
                                 if (syncMessage.getRequest().isPresent()) {
                                     group = handleSignalServiceDataMessage(message, true, envelope.getSource(), syncMessage.getSent().get().getDestination().get());
                                 }
                                 if (syncMessage.getRequest().isPresent()) {

-                                    // TODO
+                                    RequestMessage rm = syncMessage.getRequest().get();
+                                    if (rm.isContactsRequest()) {
+                                        // TODO implement when we have contacts
+                                    }
+                                    if (rm.isGroupsRequest()) {
+                                        try {
+                                            sendGroups();
+                                        } catch (EncapsulatedExceptions encapsulatedExceptions) {
+                                            encapsulatedExceptions.printStackTrace();
+                                        } catch (UntrustedIdentityException e) {
+                                            e.printStackTrace();
+                                        }
+                                    }

                                 }
                                 if (syncMessage.getGroups().isPresent()) {
                                 }
                                 if (syncMessage.getGroups().isPresent()) {

-                                    // TODO
+                                    try {
+                                        DeviceGroupsInputStream s = new DeviceGroupsInputStream(retrieveAttachmentAsStream(syncMessage.getGroups().get().asPointer()));
+                                        DeviceGroup g;
+                                        while ((g = s.read()) != null) {
+                                            GroupInfo syncGroup;
+                                            try {
+                                                syncGroup = groupStore.getGroup(g.getId());
+                                            } catch (GroupNotFoundException e) {
+                                                syncGroup = new GroupInfo(g.getId());
+                                            }
+                                            if (g.getName().isPresent()) {
+                                                syncGroup.name = g.getName().get();
+                                            }
+                                            syncGroup.members.addAll(g.getMembers());
+                                            syncGroup.active = g.isActive();
+
+                                            if (g.getAvatar().isPresent()) {
+                                                byte[] ava = new byte[(int) g.getAvatar().get().getLength()];
+                                                org.whispersystems.signalservice.internal.util.Util.readFully(g.getAvatar().get().getInputStream(), ava);
+                                                // TODO store group avatar in /avatar/groups folder
+                                            }
+                                            groupStore.updateGroup(syncGroup);
+                                        }
+                                    } catch (Exception e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                                if (syncMessage.getContacts().isPresent()) {
+                                    try {
+                                        DeviceContactsInputStream s = new DeviceContactsInputStream(retrieveAttachmentAsStream(syncMessage.getContacts().get().asPointer()));
+                                        DeviceContact c;
+                                        while ((c = s.read()) != null) {
+                                            // TODO implement when we have contact storage
+                                            if (c.getName().isPresent()) {
+                                                c.getName().get();
+                                            }
+                                            c.getNumber();
+
+                                            if (c.getAvatar().isPresent()) {
+                                                byte[] ava = new byte[(int) c.getAvatar().get().getLength()];
+                                                org.whispersystems.signalservice.internal.util.Util.readFully(c.getAvatar().get().getInputStream(), ava);
+                                                // TODO store contact avatar in /avatar/contacts folder
+                                            }
+                                        }
+                                    } catch (Exception e) {
+                                        e.printStackTrace();
+                                    }

                                 }
                             }
                         }
                                 }
                             }
                         }


@@ -676,6 +841,14 @@ class Manager implements Signal {
         return outputFile;
     }
 
         return outputFile;
     }
 

+    private InputStream retrieveAttachmentAsStream(SignalServiceAttachmentPointer pointer) throws IOException, InvalidMessageException {
+        final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(URL, TRUST_STORE, username, password, deviceId, signalingKey, USER_AGENT);
+        File file = File.createTempFile("ts_tmp", "tmp");
+        file.deleteOnExit();
+
+        return messageReceiver.retrieveAttachment(pointer, file);
+    }
+

     private String canonicalizeNumber(String number) throws InvalidNumberException {
         String localNumber = username;
         return PhoneNumberFormatter.formatNumber(number, localNumber);
     private String canonicalizeNumber(String number) throws InvalidNumberException {
         String localNumber = username;
         return PhoneNumberFormatter.formatNumber(number, localNumber);


@@ -690,4 +863,34 @@ class Manager implements Signal {
     public boolean isRemote() {
         return false;
     }
     public boolean isRemote() {
         return false;
     }

+
+    private void sendGroups() throws IOException, EncapsulatedExceptions, UntrustedIdentityException {
+        File contactsFile = File.createTempFile("multidevice-contact-update", ".tmp");
+
+        try {
+            DeviceGroupsOutputStream out = new DeviceGroupsOutputStream(new FileOutputStream(contactsFile));
+            try {
+                for (GroupInfo record : groupStore.getGroups()) {
+                    out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name),
+                            new ArrayList<>(record.members), Optional.of(new SignalServiceAttachmentStream(new FileInputStream("/home/sebastian/Bilder/00026_150512_14-00-18.JPG"), "octet", new File("/home/sebastian/Bilder/00026_150512_14-00-18.JPG").length(), null)),
+                            record.active));
+                }
+            } finally {
+                out.close();
+            }
+
+            if (contactsFile.exists() && contactsFile.length() > 0) {
+                FileInputStream contactsFileStream = new FileInputStream(contactsFile);
+                SignalServiceAttachmentStream attachmentStream = SignalServiceAttachment.newStreamBuilder()
+                        .withStream(contactsFileStream)
+                        .withContentType("application/octet-stream")
+                        .withLength(contactsFile.length())
+                        .build();
+
+                sendMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
+            }
+        } finally {
+            if (contactsFile != null) contactsFile.delete();
+        }
+    }

 }
 }