import org.whispersystems.textsecure.api.TextSecureMessageReceiver;
import org.whispersystems.textsecure.api.TextSecureMessageSender;
import org.whispersystems.textsecure.api.crypto.TextSecureCipher;
-import org.whispersystems.textsecure.api.messages.TextSecureAttachmentPointer;
-import org.whispersystems.textsecure.api.messages.TextSecureContent;
-import org.whispersystems.textsecure.api.messages.TextSecureDataMessage;
-import org.whispersystems.textsecure.api.messages.TextSecureEnvelope;
+import org.whispersystems.textsecure.api.messages.*;
import org.whispersystems.textsecure.api.push.TextSecureAddress;
import org.whispersystems.textsecure.api.push.TrustStore;
import org.whispersystems.textsecure.api.push.exceptions.EncapsulatedExceptions;
import org.whispersystems.textsecure.api.util.PhoneNumberFormatter;
import java.io.*;
-import java.util.LinkedList;
-import java.util.List;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-class Manager {
+class Manager implements TextSecure {
private final static String URL = "https://textsecure-service.whispersystems.org";
private final static TrustStore TRUST_STORE = new WhisperTrustStore();
private JsonAxolotlStore axolotlStore;
private TextSecureAccountManager accountManager;
+ private JsonGroupStore groupStore;
public Manager(String username) {
this.username = username;
return node;
}
-
public void load() throws IOException, InvalidKeyException {
JsonNode rootNode = jsonProcessot.readTree(new File(getFileName()));
}
axolotlStore = jsonProcessot.convertValue(getNotNullNode(rootNode, "axolotlStore"), JsonAxolotlStore.class); //new JsonAxolotlStore(in.getJSONObject("axolotlStore"));
registered = getNotNullNode(rootNode, "registered").asBoolean();
+ JsonNode groupStoreNode = rootNode.get("groupStore");
+ if (groupStoreNode != null) {
+ groupStore = jsonProcessot.convertValue(groupStoreNode, JsonGroupStore.class);
+ }
+ if (groupStore == null) {
+ groupStore = new JsonGroupStore();
+ }
accountManager = new TextSecureAccountManager(URL, TRUST_STORE, username, password, USER_AGENT);
}
.put("nextSignedPreKeyId", nextSignedPreKeyId)
.put("registered", registered)
.putPOJO("axolotlStore", axolotlStore)
+ .putPOJO("groupStore", groupStore)
;
try {
jsonProcessot.writeValue(new File(getFileName()), rootNode);
IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair();
int registrationId = KeyHelper.generateRegistrationId(false);
axolotlStore = new JsonAxolotlStore(identityKey, registrationId);
+ groupStore = new JsonGroupStore();
registered = false;
}
accountManager.setPreKeys(axolotlStore.getIdentityKeyPair().getPublicKey(), lastResortKey, signedPreKeyRecord, oneTimePreKeys);
}
- public void sendMessage(List<TextSecureAddress> recipients, TextSecureDataMessage message)
+
+ private static List<TextSecureAttachment> getTextSecureAttachments(List<String> attachments) throws AttachmentInvalidException {
+ List<TextSecureAttachment> textSecureAttachments = null;
+ if (attachments != null) {
+ textSecureAttachments = new ArrayList<>(attachments.size());
+ for (String attachment : attachments) {
+ try {
+ textSecureAttachments.add(createAttachment(attachment));
+ } catch (IOException e) {
+ throw new AttachmentInvalidException(attachment, e);
+ }
+ }
+ }
+ return textSecureAttachments;
+ }
+
+ private static TextSecureAttachmentStream createAttachment(String attachment) throws IOException {
+ File attachmentFile = new File(attachment);
+ InputStream attachmentStream = new FileInputStream(attachmentFile);
+ final long attachmentSize = attachmentFile.length();
+ String mime = Files.probeContentType(Paths.get(attachment));
+ return new TextSecureAttachmentStream(attachmentStream, mime, attachmentSize, null);
+ }
+
+ @Override
+ public void sendGroupMessage(String messageText, List<String> attachments,
+ byte[] groupId)
+ throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException {
+ final TextSecureDataMessage.Builder messageBuilder = TextSecureDataMessage.newBuilder().withBody(messageText);
+ if (attachments != null) {
+ messageBuilder.withAttachments(getTextSecureAttachments(attachments));
+ }
+ if (groupId != null) {
+ TextSecureGroup group = TextSecureGroup.newBuilder(TextSecureGroup.Type.DELIVER)
+ .withId(groupId)
+ .build();
+ messageBuilder.asGroupMessage(group);
+ }
+ TextSecureDataMessage message = messageBuilder.build();
+
+ sendMessage(message, getGroupInfo(groupId).members);
+ }
+
+ public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions {
+ TextSecureGroup group = TextSecureGroup.newBuilder(TextSecureGroup.Type.QUIT)
+ .withId(groupId)
+ .build();
+
+ TextSecureDataMessage message = TextSecureDataMessage.newBuilder()
+ .asGroupMessage(group)
+ .build();
+
+ sendMessage(message, getGroupInfo(groupId).members);
+ }
+
+ public byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<String> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException {
+ GroupInfo g;
+ if (groupId == null) {
+ // Create new group
+ g = new GroupInfo(Util.getSecretBytes(16));
+ g.members.add(username);
+ } else {
+ g = getGroupInfo(groupId);
+ }
+
+ if (name != null) {
+ g.name = name;
+ }
+
+ if (members != null) {
+ for (String member : members) {
+ try {
+ g.members.add(canonicalizeNumber(member));
+ } catch (InvalidNumberException e) {
+ System.err.println("Failed to add member \"" + member + "\" to group: " + e.getMessage());
+ System.err.println("Aborting…");
+ System.exit(1);
+ }
+ }
+ }
+
+ TextSecureGroup.Builder group = TextSecureGroup.newBuilder(TextSecureGroup.Type.UPDATE)
+ .withId(g.groupId)
+ .withName(g.name)
+ .withMembers(new ArrayList<>(g.members));
+
+ if (avatarFile != null) {
+ try {
+ group.withAvatar(createAttachment(avatarFile));
+ // TODO
+ g.avatarId = 0;
+ } catch (IOException e) {
+ throw new AttachmentInvalidException(avatarFile, e);
+ }
+ }
+
+ setGroupInfo(g);
+
+ TextSecureDataMessage message = TextSecureDataMessage.newBuilder()
+ .asGroupMessage(group.build())
+ .build();
+
+ sendMessage(message, g.members);
+ return g.groupId;
+ }
+
+ @Override
+ public void sendMessage(String message, List<String> attachments, String recipient)
+ throws EncapsulatedExceptions, AttachmentInvalidException, IOException {
+ List<String> recipients = new ArrayList<>(1);
+ recipients.add(recipient);
+ sendMessage(message, attachments, recipients);
+ }
+
+ public void sendMessage(String messageText, List<String> attachments,
+ Collection<String> recipients)
+ throws IOException, EncapsulatedExceptions, AttachmentInvalidException {
+ final TextSecureDataMessage.Builder messageBuilder = TextSecureDataMessage.newBuilder().withBody(messageText);
+ if (attachments != null) {
+ messageBuilder.withAttachments(getTextSecureAttachments(attachments));
+ }
+ TextSecureDataMessage message = messageBuilder.build();
+
+ sendMessage(message, recipients);
+ }
+
+ public void sendEndSessionMessage(List<String> recipients) throws IOException, EncapsulatedExceptions {
+ TextSecureDataMessage message = TextSecureDataMessage.newBuilder()
+ .asEndSessionMessage()
+ .build();
+
+ sendMessage(message, recipients);
+ }
+
+ private void sendMessage(TextSecureDataMessage message, Collection<String> recipients)
throws IOException, EncapsulatedExceptions {
TextSecureMessageSender messageSender = new TextSecureMessageSender(URL, TRUST_STORE, username, password,
axolotlStore, USER_AGENT, Optional.<TextSecureMessageSender.EventListener>absent());
- messageSender.sendMessage(recipients, message);
+
+ Set<TextSecureAddress> 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.");
+ return;
+ }
+ }
+
+ messageSender.sendMessage(new ArrayList<>(recipientsTS), message);
+
+ if (message.isEndSession()) {
+ for (TextSecureAddress recipient : recipientsTS) {
+ handleEndSession(recipient.getNumber());
+ }
+ }
+ save();
}
- public TextSecureContent decryptMessage(TextSecureEnvelope envelope) {
+ private TextSecureContent decryptMessage(TextSecureEnvelope envelope) {
TextSecureCipher cipher = new TextSecureCipher(new TextSecureAddress(username), axolotlStore);
try {
return cipher.decrypt(envelope);
}
}
- public void handleEndSession(String source) {
+ private void handleEndSession(String source) {
axolotlStore.deleteAllSessions(source);
}
public interface ReceiveMessageHandler {
- void handleMessage(TextSecureEnvelope envelope);
+ void handleMessage(TextSecureEnvelope envelope, TextSecureContent decryptedContent, GroupInfo group);
}
public void receiveMessages(int timeoutSeconds, boolean returnOnTimeout, ReceiveMessageHandler handler) throws IOException {
while (true) {
TextSecureEnvelope envelope;
+ TextSecureContent content = null;
+ GroupInfo group = null;
try {
envelope = messagePipe.read(timeoutSeconds, TimeUnit.SECONDS);
- handler.handleMessage(envelope);
+ if (!envelope.isReceipt()) {
+ content = decryptMessage(envelope);
+ if (content != null) {
+ if (content.getDataMessage().isPresent()) {
+ TextSecureDataMessage message = content.getDataMessage().get();
+ if (message.getGroupInfo().isPresent()) {
+ TextSecureGroup groupInfo = message.getGroupInfo().get();
+ switch (groupInfo.getType()) {
+ case UPDATE:
+ try {
+ group = groupStore.getGroup(groupInfo.getGroupId());
+ } catch (GroupNotFoundException e) {
+ group = new GroupInfo(groupInfo.getGroupId());
+ }
+
+ if (groupInfo.getAvatar().isPresent()) {
+ TextSecureAttachment avatar = groupInfo.getAvatar().get();
+ if (avatar.isPointer()) {
+ long avatarId = avatar.asPointer().getId();
+ try {
+ retrieveAttachment(avatar.asPointer());
+ group.avatarId = avatarId;
+ } catch (IOException | InvalidMessageException e) {
+ System.err.println("Failed to retrieve group avatar (" + avatarId + "): " + e.getMessage());
+ }
+ }
+ }
+
+ if (groupInfo.getName().isPresent()) {
+ group.name = groupInfo.getName().get();
+ }
+
+ if (groupInfo.getMembers().isPresent()) {
+ group.members.addAll(groupInfo.getMembers().get());
+ }
+
+ groupStore.updateGroup(group);
+ break;
+ case DELIVER:
+ try {
+ group = groupStore.getGroup(groupInfo.getGroupId());
+ } catch (GroupNotFoundException e) {
+ }
+ break;
+ case QUIT:
+ try {
+ group = groupStore.getGroup(groupInfo.getGroupId());
+ group.members.remove(envelope.getSource());
+ } catch (GroupNotFoundException e) {
+ }
+ break;
+ }
+ }
+ if (message.isEndSession()) {
+ handleEndSession(envelope.getSource());
+ }
+ if (message.getAttachments().isPresent()) {
+ for (TextSecureAttachment attachment : message.getAttachments().get()) {
+ if (attachment.isPointer()) {
+ try {
+ retrieveAttachment(attachment.asPointer());
+ } catch (IOException | InvalidMessageException e) {
+ System.err.println("Failed to retrieve attachment (" + attachment.asPointer().getId() + "): " + e.getMessage());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ save();
+ handler.handleMessage(envelope, content, group);
} catch (TimeoutException e) {
if (returnOnTimeout)
return;
} catch (InvalidVersionException e) {
System.err.println("Ignoring error: " + e.getMessage());
}
- save();
}
} finally {
if (messagePipe != null)
}
}
- public File retrieveAttachment(TextSecureAttachmentPointer pointer) throws IOException, InvalidMessageException {
+ public File getAttachmentFile(long attachmentId) {
+ return new File(attachmentsPath + "/" + attachmentId);
+ }
+
+ private File retrieveAttachment(TextSecureAttachmentPointer pointer) throws IOException, InvalidMessageException {
final TextSecureMessageReceiver messageReceiver = new TextSecureMessageReceiver(URL, TRUST_STORE, username, password, signalingKey, USER_AGENT);
File tmpFile = File.createTempFile("ts_attach_" + pointer.getId(), ".tmp");
InputStream input = messageReceiver.retrieveAttachment(pointer, tmpFile);
new File(attachmentsPath).mkdirs();
- File outputFile = new File(attachmentsPath + "/" + pointer.getId());
+ File outputFile = getAttachmentFile(pointer.getId());
OutputStream output = null;
try {
output = new FileOutputStream(outputFile);
return PhoneNumberFormatter.formatNumber(number, localNumber);
}
- TextSecureAddress getPushAddress(String number) throws InvalidNumberException {
+ private TextSecureAddress getPushAddress(String number) throws InvalidNumberException {
String e164number = canonicalizeNumber(number);
return new TextSecureAddress(e164number);
}
+
+ private GroupInfo getGroupInfo(byte[] groupId) throws GroupNotFoundException {
+ return groupStore.getGroup(groupId);
+ }
+
+ private void setGroupInfo(GroupInfo group) {
+ groupStore.updateGroup(group);
+ }
+
+ @Override
+ public boolean isRemote() {
+ return false;
+ }
}
git.nmode.ca / signal-cli / blobdiff
