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.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.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.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.internal.push.SignalServiceProtos;
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;
registered = true;
refreshPreKeys();
+
+ requestSyncGroups();
+ requestSyncContacts();
+
+ save();
+ }
+
+
+ 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.getQuery());
+ 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);
+
+ addDeviceLink(deviceIdentifier, deviceKey);
+ }
+
+ private void addDeviceLink(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() {
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();
}
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 {
.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 {
.asGroupMessage(group.build())
.build();
- sendMessage(message, g.members);
+ final Set<String> membersSend = g.members;
+ membersSend.remove(this.username);
+ sendMessage(message, membersSend);
return g.groupId;
}
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());
+ 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) {
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());
try {
group = groupStore.getGroup(groupInfo.getGroupId());
group.members.remove(source);
+ groupStore.updateGroup(group);
} catch (GroupNotFoundException e) {
}
break;
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()) {
- // 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();
+ }
}
}
}
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);
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();
+ }
+ }
}
git.nmode.ca / signal-cli / blobdiff
