nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/Manager.java

   1 /**
   2  * Copyright (C) 2015 AsamK
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 package org.asamk.signal;
  18
  19 import com.fasterxml.jackson.annotation.JsonAutoDetect;
  20 import com.fasterxml.jackson.annotation.PropertyAccessor;
  21 import com.fasterxml.jackson.core.JsonGenerator;
  22 import com.fasterxml.jackson.core.JsonParser;
  23 import com.fasterxml.jackson.databind.DeserializationFeature;
  24 import com.fasterxml.jackson.databind.JsonNode;
  25 import com.fasterxml.jackson.databind.ObjectMapper;
  26 import com.fasterxml.jackson.databind.SerializationFeature;
  27 import com.fasterxml.jackson.databind.node.ObjectNode;
  28 import org.apache.http.util.TextUtils;
  29 import org.asamk.Signal;
  30 import org.asamk.signal.storage.contacts.ContactInfo;
  31 import org.asamk.signal.storage.contacts.JsonContactsStore;
  32 import org.asamk.signal.storage.groups.GroupInfo;
  33 import org.asamk.signal.storage.groups.JsonGroupStore;
  34 import org.asamk.signal.storage.protocol.JsonIdentityKeyStore;
  35 import org.asamk.signal.storage.protocol.JsonSignalProtocolStore;
  36 import org.asamk.signal.storage.threads.JsonThreadStore;
  37 import org.asamk.signal.storage.threads.ThreadInfo;
  38 import org.asamk.signal.util.Base64;
  39 import org.asamk.signal.util.Util;
  40 import org.whispersystems.libsignal.*;
  41 import org.whispersystems.libsignal.ecc.Curve;
  42 import org.whispersystems.libsignal.ecc.ECKeyPair;
  43 import org.whispersystems.libsignal.ecc.ECPublicKey;
  44 import org.whispersystems.libsignal.fingerprint.Fingerprint;
  45 import org.whispersystems.libsignal.fingerprint.NumericFingerprintGenerator;
  46 import org.whispersystems.libsignal.state.PreKeyRecord;
  47 import org.whispersystems.libsignal.state.SignedPreKeyRecord;
  48 import org.whispersystems.libsignal.util.KeyHelper;
  49 import org.whispersystems.libsignal.util.Medium;
  50 import org.whispersystems.libsignal.util.guava.Optional;
  51 import org.whispersystems.signalservice.api.SignalServiceAccountManager;
  52 import org.whispersystems.signalservice.api.SignalServiceMessagePipe;
  53 import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
  54 import org.whispersystems.signalservice.api.SignalServiceMessageSender;
  55 import org.whispersystems.signalservice.api.crypto.SignalServiceCipher;
  56 import org.whispersystems.signalservice.api.crypto.UntrustedIdentityException;
  57 import org.whispersystems.signalservice.api.messages.*;
  58 import org.whispersystems.signalservice.api.messages.multidevice.*;
  59 import org.whispersystems.signalservice.api.push.ContactTokenDetails;
  60 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  61 import org.whispersystems.signalservice.api.push.TrustStore;
  62 import org.whispersystems.signalservice.api.push.exceptions.*;
  63 import org.whispersystems.signalservice.api.util.InvalidNumberException;
  64 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
  65 import org.whispersystems.signalservice.internal.push.SignalServiceProtos;
  66 import org.whispersystems.signalservice.internal.push.SignalServiceUrl;
  67
  68 import java.io.*;
  69 import java.net.URI;
  70 import java.net.URISyntaxException;
  71 import java.net.URLDecoder;
  72 import java.net.URLEncoder;
  73 import java.nio.channels.Channels;
  74 import java.nio.channels.FileChannel;
  75 import java.nio.channels.FileLock;
  76 import java.nio.file.Files;
  77 import java.nio.file.Path;
  78 import java.nio.file.Paths;
  79 import java.nio.file.StandardCopyOption;
  80 import java.nio.file.attribute.PosixFilePermission;
  81 import java.nio.file.attribute.PosixFilePermissions;
  82 import java.util.*;
  83 import java.util.concurrent.TimeUnit;
  84 import java.util.concurrent.TimeoutException;
  85
  86 import static java.nio.file.attribute.PosixFilePermission.*;
  87
  88 class Manager implements Signal {
  89     private final static String URL = "https://textsecure-service.whispersystems.org";
  90     private final static TrustStore TRUST_STORE = new WhisperTrustStore();
  91     private final static SignalServiceUrl[] serviceUrls = new SignalServiceUrl[]{new SignalServiceUrl(URL, TRUST_STORE)};
  92
  93     public final static String PROJECT_NAME = Manager.class.getPackage().getImplementationTitle();
  94     public final static String PROJECT_VERSION = Manager.class.getPackage().getImplementationVersion();
  95     private final static String USER_AGENT = PROJECT_NAME == null ? null : PROJECT_NAME + " " + PROJECT_VERSION;
  96
  97     private final static int PREKEY_MINIMUM_COUNT = 20;
  98     private static final int PREKEY_BATCH_SIZE = 100;
  99     private static final int MAX_ATTACHMENT_SIZE = 150 * 1024  * 1024;
 100
 101     private final String settingsPath;
 102     private final String dataPath;
 103     private final String attachmentsPath;
 104     private final String avatarsPath;
 105
 106     private FileChannel fileChannel;
 107     private FileLock lock;
 108
 109     private final ObjectMapper jsonProcessor = new ObjectMapper();
 110     private String username;
 111     private int deviceId = SignalServiceAddress.DEFAULT_DEVICE_ID;
 112     private String password;
 113     private String signalingKey;
 114     private int preKeyIdOffset;
 115     private int nextSignedPreKeyId;
 116
 117     private boolean registered = false;
 118
 119     private JsonSignalProtocolStore signalProtocolStore;
 120     private SignalServiceAccountManager accountManager;
 121     private JsonGroupStore groupStore;
 122     private JsonContactsStore contactStore;
 123     private JsonThreadStore threadStore;
 124     private SignalServiceMessagePipe messagePipe = null;
 125
 126     public Manager(String username, String settingsPath) {
 127         this.username = username;
 128         this.settingsPath = settingsPath;
 129         this.dataPath = this.settingsPath + "/data";
 130         this.attachmentsPath = this.settingsPath + "/attachments";
 131         this.avatarsPath = this.settingsPath + "/avatars";
 132
 133         jsonProcessor.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE); // disable autodetect
 134         jsonProcessor.enable(SerializationFeature.INDENT_OUTPUT); // for pretty print, you can disable it.
 135         jsonProcessor.enable(SerializationFeature.WRITE_NULL_MAP_VALUES);
 136         jsonProcessor.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
 137         jsonProcessor.disable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
 138         jsonProcessor.disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET);
 139     }
 140
 141     public String getUsername() {
 142         return username;
 143     }
 144
 145     private IdentityKey getIdentity() {
 146         return signalProtocolStore.getIdentityKeyPair().getPublicKey();
 147     }
 148
 149     public int getDeviceId() {
 150         return deviceId;
 151     }
 152
 153     public String getFileName() {
 154         return dataPath + "/" + username;
 155     }
 156
 157     private String getMessageCachePath() {
 158         return this.dataPath + "/" + username + ".d/msg-cache";
 159     }
 160
 161     private String getMessageCachePath(String sender) {
 162         return getMessageCachePath() + "/" + sender.replace("/", "_");
 163     }
 164
 165     private File getMessageCacheFile(String sender, long now, long timestamp) throws IOException {
 166         String cachePath = getMessageCachePath(sender);
 167         createPrivateDirectories(cachePath);
 168         return new File(cachePath + "/" + now + "_" + timestamp);
 169     }
 170
 171     private static void createPrivateDirectories(String path) throws IOException {
 172         final Path file = new File(path).toPath();
 173         try {
 174             Set<PosixFilePermission> perms = EnumSet.of(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE);
 175             Files.createDirectories(file, PosixFilePermissions.asFileAttribute(perms));
 176         } catch (UnsupportedOperationException e) {
 177             Files.createDirectories(file);
 178         }
 179     }
 180
 181     private static void createPrivateFile(String path) throws IOException {
 182         final Path file = new File(path).toPath();
 183         try {
 184             Set<PosixFilePermission> perms = EnumSet.of(OWNER_READ, OWNER_WRITE);
 185             Files.createFile(file, PosixFilePermissions.asFileAttribute(perms));
 186         } catch (UnsupportedOperationException e) {
 187             Files.createFile(file);
 188         }
 189     }
 190
 191     public boolean userExists() {
 192         if (username == null) {
 193             return false;
 194         }
 195         File f = new File(getFileName());
 196         return !(!f.exists() || f.isDirectory());
 197     }
 198
 199     public boolean userHasKeys() {
 200         return signalProtocolStore != null;
 201     }
 202
 203     private JsonNode getNotNullNode(JsonNode parent, String name) throws InvalidObjectException {
 204         JsonNode node = parent.get(name);
 205         if (node == null) {
 206             throw new InvalidObjectException(String.format("Incorrect file format: expected parameter %s not found ", name));
 207         }
 208
 209         return node;
 210     }
 211
 212     private void openFileChannel() throws IOException {
 213         if (fileChannel != null)
 214             return;
 215
 216         createPrivateDirectories(dataPath);
 217         if (!new File(getFileName()).exists()) {
 218             createPrivateFile(getFileName());
 219         }
 220         fileChannel = new RandomAccessFile(new File(getFileName()), "rw").getChannel();
 221         lock = fileChannel.tryLock();
 222         if (lock == null) {
 223             System.err.println("Config file is in use by another instance, waiting…");
 224             lock = fileChannel.lock();
 225             System.err.println("Config file lock acquired.");
 226         }
 227     }
 228
 229     public void init() throws IOException {
 230         load();
 231
 232         migrateLegacyConfigs();
 233
 234         accountManager = new SignalServiceAccountManager(serviceUrls, username, password, deviceId, USER_AGENT);
 235         try {
 236             if (registered && accountManager.getPreKeysCount() < PREKEY_MINIMUM_COUNT) {
 237                 refreshPreKeys();
 238                 save();
 239             }
 240         } catch (AuthorizationFailedException e) {
 241             System.err.println("Authorization failed, was the number registered elsewhere?");
 242         }
 243     }
 244
 245     private void load() throws IOException {
 246         openFileChannel();
 247         JsonNode rootNode = jsonProcessor.readTree(Channels.newInputStream(fileChannel));
 248
 249         JsonNode node = rootNode.get("deviceId");
 250         if (node != null) {
 251             deviceId = node.asInt();
 252         }
 253         username = getNotNullNode(rootNode, "username").asText();
 254         password = getNotNullNode(rootNode, "password").asText();
 255         if (rootNode.has("signalingKey")) {
 256             signalingKey = getNotNullNode(rootNode, "signalingKey").asText();
 257         }
 258         if (rootNode.has("preKeyIdOffset")) {
 259             preKeyIdOffset = getNotNullNode(rootNode, "preKeyIdOffset").asInt(0);
 260         } else {
 261             preKeyIdOffset = 0;
 262         }
 263         if (rootNode.has("nextSignedPreKeyId")) {
 264             nextSignedPreKeyId = getNotNullNode(rootNode, "nextSignedPreKeyId").asInt();
 265         } else {
 266             nextSignedPreKeyId = 0;
 267         }
 268         signalProtocolStore = jsonProcessor.convertValue(getNotNullNode(rootNode, "axolotlStore"), JsonSignalProtocolStore.class);
 269         registered = getNotNullNode(rootNode, "registered").asBoolean();
 270         JsonNode groupStoreNode = rootNode.get("groupStore");
 271         if (groupStoreNode != null) {
 272             groupStore = jsonProcessor.convertValue(groupStoreNode, JsonGroupStore.class);
 273         }
 274         if (groupStore == null) {
 275             groupStore = new JsonGroupStore();
 276         }
 277
 278         JsonNode contactStoreNode = rootNode.get("contactStore");
 279         if (contactStoreNode != null) {
 280             contactStore = jsonProcessor.convertValue(contactStoreNode, JsonContactsStore.class);
 281         }
 282         if (contactStore == null) {
 283             contactStore = new JsonContactsStore();
 284         }
 285         JsonNode threadStoreNode = rootNode.get("threadStore");
 286         if (threadStoreNode != null) {
 287             threadStore = jsonProcessor.convertValue(threadStoreNode, JsonThreadStore.class);
 288         }
 289         if (threadStore == null) {
 290             threadStore = new JsonThreadStore();
 291         }
 292     }
 293
 294     private void migrateLegacyConfigs() {
 295         // Copy group avatars that were previously stored in the attachments folder
 296         // to the new avatar folder
 297         if (JsonGroupStore.groupsWithLegacyAvatarId.size() > 0) {
 298             for (GroupInfo g : JsonGroupStore.groupsWithLegacyAvatarId) {
 299                 File avatarFile = getGroupAvatarFile(g.groupId);
 300                 File attachmentFile = getAttachmentFile(g.getAvatarId());
 301                 if (!avatarFile.exists() && attachmentFile.exists()) {
 302                     try {
 303                         createPrivateDirectories(avatarsPath);
 304                         Files.copy(attachmentFile.toPath(), avatarFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
 305                     } catch (Exception e) {
 306                         // Ignore
 307                     }
 308                 }
 309             }
 310             JsonGroupStore.groupsWithLegacyAvatarId.clear();
 311             save();
 312         }
 313     }
 314
 315     private void save() {
 316         if (username == null) {
 317             return;
 318         }
 319         ObjectNode rootNode = jsonProcessor.createObjectNode();
 320         rootNode.put("username", username)
 321                 .put("deviceId", deviceId)
 322                 .put("password", password)
 323                 .put("signalingKey", signalingKey)
 324                 .put("preKeyIdOffset", preKeyIdOffset)
 325                 .put("nextSignedPreKeyId", nextSignedPreKeyId)
 326                 .put("registered", registered)
 327                 .putPOJO("axolotlStore", signalProtocolStore)
 328                 .putPOJO("groupStore", groupStore)
 329                 .putPOJO("contactStore", contactStore)
 330                 .putPOJO("threadStore", threadStore)
 331         ;
 332         try {
 333             openFileChannel();
 334             fileChannel.position(0);
 335             jsonProcessor.writeValue(Channels.newOutputStream(fileChannel), rootNode);
 336             fileChannel.truncate(fileChannel.position());
 337             fileChannel.force(false);
 338         } catch (Exception e) {
 339             System.err.println(String.format("Error saving file: %s", e.getMessage()));
 340         }
 341     }
 342
 343     public void createNewIdentity() {
 344         IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair();
 345         int registrationId = KeyHelper.generateRegistrationId(false);
 346         signalProtocolStore = new JsonSignalProtocolStore(identityKey, registrationId);
 347         groupStore = new JsonGroupStore();
 348         registered = false;
 349         save();
 350     }
 351
 352     public boolean isRegistered() {
 353         return registered;
 354     }
 355
 356     public void register(boolean voiceVerification) throws IOException {
 357         password = Util.getSecret(18);
 358
 359         accountManager = new SignalServiceAccountManager(serviceUrls, username, password, USER_AGENT);
 360
 361         if (voiceVerification)
 362             accountManager.requestVoiceVerificationCode();
 363         else
 364             accountManager.requestSmsVerificationCode();
 365
 366         registered = false;
 367         save();
 368     }
 369
 370     public void updateAccountAttributes() throws IOException {
 371         accountManager.setAccountAttributes(signalingKey, signalProtocolStore.getLocalRegistrationId(), false, false, true);
 372     }
 373
 374     public void unregister() throws IOException {
 375         // When setting an empty GCM id, the Signal-Server also sets the fetchesMessages property to false.
 376         // If this is the master device, other users can't send messages to this number anymore.
 377         // If this is a linked device, other users can still send messages, but this device doesn't receive them anymore.
 378         accountManager.setGcmId(Optional.<String>absent());
 379     }
 380
 381     public URI getDeviceLinkUri() throws TimeoutException, IOException {
 382         password = Util.getSecret(18);
 383
 384         accountManager = new SignalServiceAccountManager(serviceUrls, username, password, USER_AGENT);
 385         String uuid = accountManager.getNewDeviceUuid();
 386
 387         registered = false;
 388         try {
 389             return new URI("tsdevice:/?uuid=" + URLEncoder.encode(uuid, "utf-8") + "&pub_key=" + URLEncoder.encode(Base64.encodeBytesWithoutPadding(signalProtocolStore.getIdentityKeyPair().getPublicKey().serialize()), "utf-8"));
 390         } catch (URISyntaxException e) {
 391             // Shouldn't happen
 392             return null;
 393         }
 394     }
 395
 396     public void finishDeviceLink(String deviceName) throws IOException, InvalidKeyException, TimeoutException, UserAlreadyExists {
 397         signalingKey = Util.getSecret(52);
 398         SignalServiceAccountManager.NewDeviceRegistrationReturn ret = accountManager.finishNewDeviceRegistration(signalProtocolStore.getIdentityKeyPair(), signalingKey, false, true, signalProtocolStore.getLocalRegistrationId(), deviceName);
 399         deviceId = ret.getDeviceId();
 400         username = ret.getNumber();
 401         // TODO do this check before actually registering
 402         if (userExists()) {
 403             throw new UserAlreadyExists(username, getFileName());
 404         }
 405         signalProtocolStore = new JsonSignalProtocolStore(ret.getIdentity(), signalProtocolStore.getLocalRegistrationId());
 406
 407         registered = true;
 408         refreshPreKeys();
 409
 410         requestSyncGroups();
 411         requestSyncContacts();
 412
 413         save();
 414     }
 415
 416     public List<DeviceInfo> getLinkedDevices() throws IOException {
 417         return accountManager.getDevices();
 418     }
 419
 420     public void removeLinkedDevices(int deviceId) throws IOException {
 421         accountManager.removeDevice(deviceId);
 422     }
 423
 424     public static Map<String, String> getQueryMap(String query) {
 425         String[] params = query.split("&");
 426         Map<String, String> map = new HashMap<>();
 427         for (String param : params) {
 428             String name = null;
 429             try {
 430                 name = URLDecoder.decode(param.split("=")[0], "utf-8");
 431             } catch (UnsupportedEncodingException e) {
 432                 // Impossible
 433             }
 434             String value = null;
 435             try {
 436                 value = URLDecoder.decode(param.split("=")[1], "utf-8");
 437             } catch (UnsupportedEncodingException e) {
 438                 // Impossible
 439             }
 440             map.put(name, value);
 441         }
 442         return map;
 443     }
 444
 445     public void addDeviceLink(URI linkUri) throws IOException, InvalidKeyException {
 446         Map<String, String> query = getQueryMap(linkUri.getRawQuery());
 447         String deviceIdentifier = query.get("uuid");
 448         String publicKeyEncoded = query.get("pub_key");
 449
 450         if (TextUtils.isEmpty(deviceIdentifier) || TextUtils.isEmpty(publicKeyEncoded)) {
 451             throw new RuntimeException("Invalid device link uri");
 452         }
 453
 454         ECPublicKey deviceKey = Curve.decodePoint(Base64.decode(publicKeyEncoded), 0);
 455
 456         addDevice(deviceIdentifier, deviceKey);
 457     }
 458
 459     private void addDevice(String deviceIdentifier, ECPublicKey deviceKey) throws IOException, InvalidKeyException {
 460         IdentityKeyPair identityKeyPair = signalProtocolStore.getIdentityKeyPair();
 461         String verificationCode = accountManager.getNewDeviceVerificationCode();
 462
 463         accountManager.addDevice(deviceIdentifier, deviceKey, identityKeyPair, verificationCode);
 464     }
 465
 466     private List<PreKeyRecord> generatePreKeys() {
 467         List<PreKeyRecord> records = new LinkedList<>();
 468
 469         for (int i = 0; i < PREKEY_BATCH_SIZE; i++) {
 470             int preKeyId = (preKeyIdOffset + i) % Medium.MAX_VALUE;
 471             ECKeyPair keyPair = Curve.generateKeyPair();
 472             PreKeyRecord record = new PreKeyRecord(preKeyId, keyPair);
 473
 474             signalProtocolStore.storePreKey(preKeyId, record);
 475             records.add(record);
 476         }
 477
 478         preKeyIdOffset = (preKeyIdOffset + PREKEY_BATCH_SIZE + 1) % Medium.MAX_VALUE;
 479         save();
 480
 481         return records;
 482     }
 483
 484     private PreKeyRecord getOrGenerateLastResortPreKey() {
 485         if (signalProtocolStore.containsPreKey(Medium.MAX_VALUE)) {
 486             try {
 487                 return signalProtocolStore.loadPreKey(Medium.MAX_VALUE);
 488             } catch (InvalidKeyIdException e) {
 489                 signalProtocolStore.removePreKey(Medium.MAX_VALUE);
 490             }
 491         }
 492
 493         ECKeyPair keyPair = Curve.generateKeyPair();
 494         PreKeyRecord record = new PreKeyRecord(Medium.MAX_VALUE, keyPair);
 495
 496         signalProtocolStore.storePreKey(Medium.MAX_VALUE, record);
 497         save();
 498
 499         return record;
 500     }
 501
 502     private SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair) {
 503         try {
 504             ECKeyPair keyPair = Curve.generateKeyPair();
 505             byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize());
 506             SignedPreKeyRecord record = new SignedPreKeyRecord(nextSignedPreKeyId, System.currentTimeMillis(), keyPair, signature);
 507
 508             signalProtocolStore.storeSignedPreKey(nextSignedPreKeyId, record);
 509             nextSignedPreKeyId = (nextSignedPreKeyId + 1) % Medium.MAX_VALUE;
 510             save();
 511
 512             return record;
 513         } catch (InvalidKeyException e) {
 514             throw new AssertionError(e);
 515         }
 516     }
 517
 518     public void verifyAccount(String verificationCode) throws IOException {
 519         verificationCode = verificationCode.replace("-", "");
 520         signalingKey = Util.getSecret(52);
 521         accountManager.verifyAccountWithCode(verificationCode, signalingKey, signalProtocolStore.getLocalRegistrationId(), false, false, true);
 522
 523         //accountManager.setGcmId(Optional.of(GoogleCloudMessaging.getInstance(this).register(REGISTRATION_ID)));
 524         registered = true;
 525
 526         refreshPreKeys();
 527         save();
 528     }
 529
 530     private void refreshPreKeys() throws IOException {
 531         List<PreKeyRecord> oneTimePreKeys = generatePreKeys();
 532         PreKeyRecord lastResortKey = getOrGenerateLastResortPreKey();
 533         SignedPreKeyRecord signedPreKeyRecord = generateSignedPreKey(signalProtocolStore.getIdentityKeyPair());
 534
 535         accountManager.setPreKeys(signalProtocolStore.getIdentityKeyPair().getPublicKey(), lastResortKey, signedPreKeyRecord, oneTimePreKeys);
 536     }
 537
 538
 539     private static List<SignalServiceAttachment> getSignalServiceAttachments(List<String> attachments) throws AttachmentInvalidException {
 540         List<SignalServiceAttachment> SignalServiceAttachments = null;
 541         if (attachments != null) {
 542             SignalServiceAttachments = new ArrayList<>(attachments.size());
 543             for (String attachment : attachments) {
 544                 try {
 545                     SignalServiceAttachments.add(createAttachment(new File(attachment)));
 546                 } catch (IOException e) {
 547                     throw new AttachmentInvalidException(attachment, e);
 548                 }
 549             }
 550         }
 551         return SignalServiceAttachments;
 552     }
 553
 554     private static SignalServiceAttachmentStream createAttachment(File attachmentFile) throws IOException {
 555         InputStream attachmentStream = new FileInputStream(attachmentFile);
 556         final long attachmentSize = attachmentFile.length();
 557         String mime = Files.probeContentType(attachmentFile.toPath());
 558         if (mime == null) {
 559             mime = "application/octet-stream";
 560         }
 561         // TODO mabybe add a parameter to set the voiceNote and preview option
 562         return new SignalServiceAttachmentStream(attachmentStream, mime, attachmentSize, Optional.of(attachmentFile.getName()), false, Optional.<byte[]>absent(),null);
 563     }
 564
 565     private Optional<SignalServiceAttachmentStream> createGroupAvatarAttachment(byte[] groupId) throws IOException {
 566         File file = getGroupAvatarFile(groupId);
 567         if (!file.exists()) {
 568             return Optional.absent();
 569         }
 570
 571         return Optional.of(createAttachment(file));
 572     }
 573
 574     private Optional<SignalServiceAttachmentStream> createContactAvatarAttachment(String number) throws IOException {
 575         File file = getContactAvatarFile(number);
 576         if (!file.exists()) {
 577             return Optional.absent();
 578         }
 579
 580         return Optional.of(createAttachment(file));
 581     }
 582
 583     private GroupInfo getGroupForSending(byte[] groupId) throws GroupNotFoundException, NotAGroupMemberException {
 584         GroupInfo g = groupStore.getGroup(groupId);
 585         if (g == null) {
 586             throw new GroupNotFoundException(groupId);
 587         }
 588         for (String member : g.members) {
 589             if (member.equals(this.username)) {
 590                 return g;
 591             }
 592         }
 593         throw new NotAGroupMemberException(groupId, g.name);
 594     }
 595
 596     public List<GroupInfo> getGroups() {
 597         return groupStore.getGroups();
 598     }
 599
 600     @Override
 601     public void sendGroupMessage(String messageText, List<String> attachments,
 602                                  byte[] groupId)
 603             throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException {
 604         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
 605         if (attachments != null) {
 606             messageBuilder.withAttachments(getSignalServiceAttachments(attachments));
 607         }
 608         if (groupId != null) {
 609             SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.DELIVER)
 610                     .withId(groupId)
 611                     .build();
 612             messageBuilder.asGroupMessage(group);
 613         }
 614         ThreadInfo thread = threadStore.getThread(Base64.encodeBytes(groupId));
 615         if (thread != null) {
 616             messageBuilder.withExpiration(thread.messageExpirationTime);
 617         }
 618
 619         final GroupInfo g = getGroupForSending(groupId);
 620
 621         // Don't send group message to ourself
 622         final List<String> membersSend = new ArrayList<>(g.members);
 623         membersSend.remove(this.username);
 624         sendMessage(messageBuilder, membersSend);
 625     }
 626
 627     public void sendQuitGroupMessage(byte[] groupId) throws GroupNotFoundException, IOException, EncapsulatedExceptions {
 628         SignalServiceGroup group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.QUIT)
 629                 .withId(groupId)
 630                 .build();
 631
 632         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
 633                 .asGroupMessage(group);
 634
 635         final GroupInfo g = getGroupForSending(groupId);
 636         g.members.remove(this.username);
 637         groupStore.updateGroup(g);
 638
 639         sendMessage(messageBuilder, g.members);
 640     }
 641
 642     private static String join(CharSequence separator, Iterable<? extends CharSequence> list) {
 643         StringBuilder buf = new StringBuilder();
 644         for (CharSequence str : list) {
 645             if (buf.length() > 0) {
 646                 buf.append(separator);
 647             }
 648             buf.append(str);
 649         }
 650
 651         return buf.toString();
 652     }
 653
 654     public byte[] sendUpdateGroupMessage(byte[] groupId, String name, Collection<String> members, String avatarFile) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException {
 655         GroupInfo g;
 656         if (groupId == null) {
 657             // Create new group
 658             g = new GroupInfo(Util.getSecretBytes(16));
 659             g.members.add(username);
 660         } else {
 661             g = getGroupForSending(groupId);
 662         }
 663
 664         if (name != null) {
 665             g.name = name;
 666         }
 667
 668         if (members != null) {
 669             Set<String> newMembers = new HashSet<>();
 670             for (String member : members) {
 671                 try {
 672                     member = canonicalizeNumber(member);
 673                 } catch (InvalidNumberException e) {
 674                     System.err.println("Failed to add member \"" + member + "\" to group: " + e.getMessage());
 675                     System.err.println("Aborting…");
 676                     System.exit(1);
 677                 }
 678                 if (g.members.contains(member)) {
 679                     continue;
 680                 }
 681                 newMembers.add(member);
 682                 g.members.add(member);
 683             }
 684             final List<ContactTokenDetails> contacts = accountManager.getContacts(newMembers);
 685             if (contacts.size() != newMembers.size()) {
 686                 // Some of the new members are not registered on Signal
 687                 for (ContactTokenDetails contact : contacts) {
 688                     newMembers.remove(contact.getNumber());
 689                 }
 690                 System.err.println("Failed to add members " + join(", ", newMembers) + " to group: Not registered on Signal");
 691                 System.err.println("Aborting…");
 692                 System.exit(1);
 693             }
 694         }
 695
 696         if (avatarFile != null) {
 697             createPrivateDirectories(avatarsPath);
 698             File aFile = getGroupAvatarFile(g.groupId);
 699             Files.copy(Paths.get(avatarFile), aFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
 700         }
 701
 702         groupStore.updateGroup(g);
 703
 704         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 705
 706         // Don't send group message to ourself
 707         final List<String> membersSend = new ArrayList<>(g.members);
 708         membersSend.remove(this.username);
 709         sendMessage(messageBuilder, membersSend);
 710         return g.groupId;
 711     }
 712
 713     private void sendUpdateGroupMessage(byte[] groupId, String recipient) throws IOException, EncapsulatedExceptions {
 714         if (groupId == null) {
 715             return;
 716         }
 717         GroupInfo g = getGroupForSending(groupId);
 718
 719         if (!g.members.contains(recipient)) {
 720             return;
 721         }
 722
 723         SignalServiceDataMessage.Builder messageBuilder = getGroupUpdateMessageBuilder(g);
 724
 725         // Send group message only to the recipient who requested it
 726         final List<String> membersSend = new ArrayList<>();
 727         membersSend.add(recipient);
 728         sendMessage(messageBuilder, membersSend);
 729     }
 730
 731     private SignalServiceDataMessage.Builder getGroupUpdateMessageBuilder(GroupInfo g) {
 732         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.UPDATE)
 733                 .withId(g.groupId)
 734                 .withName(g.name)
 735                 .withMembers(new ArrayList<>(g.members));
 736
 737         File aFile = getGroupAvatarFile(g.groupId);
 738         if (aFile.exists()) {
 739             try {
 740                 group.withAvatar(createAttachment(aFile));
 741             } catch (IOException e) {
 742                 throw new AttachmentInvalidException(aFile.toString(), e);
 743             }
 744         }
 745
 746         return SignalServiceDataMessage.newBuilder()
 747                 .asGroupMessage(group.build());
 748     }
 749
 750     private void sendGroupInfoRequest(byte[] groupId, String recipient) throws IOException, EncapsulatedExceptions {
 751         if (groupId == null) {
 752             return;
 753         }
 754
 755         SignalServiceGroup.Builder group = SignalServiceGroup.newBuilder(SignalServiceGroup.Type.REQUEST_INFO)
 756                 .withId(groupId);
 757
 758         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
 759                 .asGroupMessage(group.build());
 760
 761         // Send group info request message to the recipient who sent us a message with this groupId
 762         final List<String> membersSend = new ArrayList<>();
 763         membersSend.add(recipient);
 764         sendMessage(messageBuilder, membersSend);
 765     }
 766
 767     @Override
 768     public void sendMessage(String message, List<String> attachments, String recipient)
 769             throws EncapsulatedExceptions, AttachmentInvalidException, IOException {
 770         List<String> recipients = new ArrayList<>(1);
 771         recipients.add(recipient);
 772         sendMessage(message, attachments, recipients);
 773     }
 774
 775     @Override
 776     public void sendMessage(String messageText, List<String> attachments,
 777                             List<String> recipients)
 778             throws IOException, EncapsulatedExceptions, AttachmentInvalidException {
 779         final SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder().withBody(messageText);
 780         if (attachments != null) {
 781             messageBuilder.withAttachments(getSignalServiceAttachments(attachments));
 782         }
 783         sendMessage(messageBuilder, recipients);
 784     }
 785
 786     @Override
 787     public void sendEndSessionMessage(List<String> recipients) throws IOException, EncapsulatedExceptions {
 788         SignalServiceDataMessage.Builder messageBuilder = SignalServiceDataMessage.newBuilder()
 789                 .asEndSessionMessage();
 790
 791         sendMessage(messageBuilder, recipients);
 792     }
 793
 794     @Override
 795     public String getContactName(String number) {
 796         ContactInfo contact = contactStore.getContact(number);
 797         if (contact == null) {
 798             return "";
 799         } else {
 800             return contact.name;
 801         }
 802     }
 803
 804     @Override
 805     public void setContactName(String number, String name) {
 806         ContactInfo contact = contactStore.getContact(number);
 807         if (contact == null) {
 808             contact = new ContactInfo();
 809             contact.number = number;
 810             System.out.println("Add contact " + number + " named " + name);
 811         } else {
 812             System.out.println("Updating contact " + number + " name " + contact.name + " -> " + name);
 813         }
 814         contact.name = name;
 815         contactStore.updateContact(contact);
 816         save();
 817     }
 818
 819     @Override
 820     public String getGroupName(byte[] groupId) {
 821         GroupInfo group = getGroup(groupId);
 822         if (group == null) {
 823             return "";
 824         } else {
 825             return group.name;
 826         }
 827     }
 828
 829     @Override
 830     public List<String> getGroupMembers(byte[] groupId) {
 831         GroupInfo group = getGroup(groupId);
 832         if (group == null) {
 833             return new ArrayList<String>();
 834         } else {
 835             return new ArrayList<String>(group.members);
 836         }
 837     }
 838
 839     @Override
 840     public byte[] updateGroup(byte[] groupId, String name, List<String> members, String avatar) throws IOException, EncapsulatedExceptions, GroupNotFoundException, AttachmentInvalidException {
 841         if (groupId.length == 0) {
 842             groupId = null;
 843         }
 844         if (name.isEmpty()) {
 845             name = null;
 846         }
 847         if (members.size() == 0) {
 848             members = null;
 849         }
 850         if (avatar.isEmpty()) {
 851             avatar = null;
 852         }
 853         return sendUpdateGroupMessage(groupId, name, members, avatar);
 854     }
 855
 856     private void requestSyncGroups() throws IOException {
 857         SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.GROUPS).build();
 858         SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 859         try {
 860             sendSyncMessage(message);
 861         } catch (UntrustedIdentityException e) {
 862             e.printStackTrace();
 863         }
 864     }
 865
 866     private void requestSyncContacts() throws IOException {
 867         SignalServiceProtos.SyncMessage.Request r = SignalServiceProtos.SyncMessage.Request.newBuilder().setType(SignalServiceProtos.SyncMessage.Request.Type.CONTACTS).build();
 868         SignalServiceSyncMessage message = SignalServiceSyncMessage.forRequest(new RequestMessage(r));
 869         try {
 870             sendSyncMessage(message);
 871         } catch (UntrustedIdentityException e) {
 872             e.printStackTrace();
 873         }
 874     }
 875
 876     private void sendSyncMessage(SignalServiceSyncMessage message)
 877             throws IOException, UntrustedIdentityException {
 878         SignalServiceMessageSender messageSender = new SignalServiceMessageSender(serviceUrls, username, password,
 879                 deviceId, signalProtocolStore, USER_AGENT, Optional.fromNullable(messagePipe), Optional.<SignalServiceMessageSender.EventListener>absent());
 880         try {
 881             messageSender.sendMessage(message);
 882         } catch (UntrustedIdentityException e) {
 883             signalProtocolStore.saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED);
 884             throw e;
 885         }
 886     }
 887
 888     private void sendMessage(SignalServiceDataMessage.Builder messageBuilder, Collection<String> recipients)
 889             throws EncapsulatedExceptions, IOException {
 890         Set<SignalServiceAddress> recipientsTS = getSignalServiceAddresses(recipients);
 891         if (recipientsTS == null) return;
 892
 893         SignalServiceDataMessage message = null;
 894         try {
 895             SignalServiceMessageSender messageSender = new SignalServiceMessageSender(serviceUrls, username, password,
 896                     deviceId, signalProtocolStore, USER_AGENT, Optional.fromNullable(messagePipe), Optional.<SignalServiceMessageSender.EventListener>absent());
 897
 898             message = messageBuilder.build();
 899             if (message.getGroupInfo().isPresent()) {
 900                 try {
 901                     messageSender.sendMessage(new ArrayList<>(recipientsTS), message);
 902                 } catch (EncapsulatedExceptions encapsulatedExceptions) {
 903                     for (UntrustedIdentityException e : encapsulatedExceptions.getUntrustedIdentityExceptions()) {
 904                         signalProtocolStore.saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED);
 905                     }
 906                 }
 907             } else {
 908                 // Send to all individually, so sync messages are sent correctly
 909                 List<UntrustedIdentityException> untrustedIdentities = new LinkedList<>();
 910                 List<UnregisteredUserException> unregisteredUsers = new LinkedList<>();
 911                 List<NetworkFailureException> networkExceptions = new LinkedList<>();
 912                 for (SignalServiceAddress address : recipientsTS) {
 913                     ThreadInfo thread = threadStore.getThread(address.getNumber());
 914                     if (thread != null) {
 915                         messageBuilder.withExpiration(thread.messageExpirationTime);
 916                     } else {
 917                         messageBuilder.withExpiration(0);
 918                     }
 919                     message = messageBuilder.build();
 920                     try {
 921                         messageSender.sendMessage(address, message);
 922                     } catch (UntrustedIdentityException e) {
 923                         signalProtocolStore.saveIdentity(e.getE164Number(), e.getIdentityKey(), TrustLevel.UNTRUSTED);
 924                         untrustedIdentities.add(e);
 925                     } catch (UnregisteredUserException e) {
 926                         unregisteredUsers.add(e);
 927                     } catch (PushNetworkException e) {
 928                         networkExceptions.add(new NetworkFailureException(address.getNumber(), e));
 929                     }
 930                 }
 931                 if (!untrustedIdentities.isEmpty() || !unregisteredUsers.isEmpty() || !networkExceptions.isEmpty()) {
 932                     throw new EncapsulatedExceptions(untrustedIdentities, unregisteredUsers, networkExceptions);
 933                 }
 934             }
 935         } finally {
 936             if (message != null && message.isEndSession()) {
 937                 for (SignalServiceAddress recipient : recipientsTS) {
 938                     handleEndSession(recipient.getNumber());
 939                 }
 940             }
 941             save();
 942         }
 943     }
 944
 945     private Set<SignalServiceAddress> getSignalServiceAddresses(Collection<String> recipients) {
 946         Set<SignalServiceAddress> recipientsTS = new HashSet<>(recipients.size());
 947         for (String recipient : recipients) {
 948             try {
 949                 recipientsTS.add(getPushAddress(recipient));
 950             } catch (InvalidNumberException e) {
 951                 System.err.println("Failed to add recipient \"" + recipient + "\": " + e.getMessage());
 952                 System.err.println("Aborting sending.");
 953                 save();
 954                 return null;
 955             }
 956         }
 957         return recipientsTS;
 958     }
 959
 960     private SignalServiceContent decryptMessage(SignalServiceEnvelope envelope) throws NoSessionException, LegacyMessageException, InvalidVersionException, InvalidMessageException, DuplicateMessageException, InvalidKeyException, InvalidKeyIdException, org.whispersystems.libsignal.UntrustedIdentityException {
 961         SignalServiceCipher cipher = new SignalServiceCipher(new SignalServiceAddress(username), signalProtocolStore);
 962         try {
 963             return cipher.decrypt(envelope);
 964         } catch (org.whispersystems.libsignal.UntrustedIdentityException e) {
 965             signalProtocolStore.saveIdentity(e.getName(), e.getUntrustedIdentity(), TrustLevel.UNTRUSTED);
 966             throw e;
 967         }
 968     }
 969
 970     private void handleEndSession(String source) {
 971         signalProtocolStore.deleteAllSessions(source);
 972     }
 973
 974     public interface ReceiveMessageHandler {
 975         void handleMessage(SignalServiceEnvelope envelope, SignalServiceContent decryptedContent, Throwable e);
 976     }
 977
 978     private void handleSignalServiceDataMessage(SignalServiceDataMessage message, boolean isSync, String source, String destination, boolean ignoreAttachments) {
 979         String threadId;
 980         if (message.getGroupInfo().isPresent()) {
 981             SignalServiceGroup groupInfo = message.getGroupInfo().get();
 982             threadId = Base64.encodeBytes(groupInfo.getGroupId());
 983             GroupInfo group = groupStore.getGroup(groupInfo.getGroupId());
 984             switch (groupInfo.getType()) {
 985                 case UPDATE:
 986                     if (group == null) {
 987                         group = new GroupInfo(groupInfo.getGroupId());
 988                     }
 989
 990                     if (groupInfo.getAvatar().isPresent()) {
 991                         SignalServiceAttachment avatar = groupInfo.getAvatar().get();
 992                         if (avatar.isPointer()) {
 993                             try {
 994                                 retrieveGroupAvatarAttachment(avatar.asPointer(), group.groupId);
 995                             } catch (IOException | InvalidMessageException e) {
 996                                 System.err.println("Failed to retrieve group avatar (" + avatar.asPointer().getId() + "): " + e.getMessage());
 997                             }
 998                         }
 999                     }
1000
1001                     if (groupInfo.getName().isPresent()) {
1002                         group.name = groupInfo.getName().get();
1003                     }
1004
1005                     if (groupInfo.getMembers().isPresent()) {
1006                         group.members.addAll(groupInfo.getMembers().get());
1007                     }
1008
1009                     groupStore.updateGroup(group);
1010                     break;
1011                 case DELIVER:
1012                     if (group == null) {
1013                         try {
1014                             sendGroupInfoRequest(groupInfo.getGroupId(), source);
1015                         } catch (IOException | EncapsulatedExceptions e) {
1016                             e.printStackTrace();
1017                         }
1018                     }
1019                     break;
1020                 case QUIT:
1021                     if (group == null) {
1022                         try {
1023                             sendGroupInfoRequest(groupInfo.getGroupId(), source);
1024                         } catch (IOException | EncapsulatedExceptions e) {
1025                             e.printStackTrace();
1026                         }
1027                     } else {
1028                         group.members.remove(source);
1029                         groupStore.updateGroup(group);
1030                     }
1031                     break;
1032                 case REQUEST_INFO:
1033                     if (group != null) {
1034                         try {
1035                             sendUpdateGroupMessage(groupInfo.getGroupId(), source);
1036                         } catch (IOException | EncapsulatedExceptions e) {
1037                             e.printStackTrace();
1038                         } catch (NotAGroupMemberException e) {
1039                             // We have left this group, so don't send a group update message
1040                         }
1041                     }
1042                     break;
1043             }
1044         } else {
1045             if (isSync) {
1046                 threadId = destination;
1047             } else {
1048                 threadId = source;
1049             }
1050         }
1051         if (message.isEndSession()) {
1052             handleEndSession(isSync ? destination : source);
1053         }
1054         if (message.isExpirationUpdate() || message.getBody().isPresent()) {
1055             ThreadInfo thread = threadStore.getThread(threadId);
1056             if (thread == null) {
1057                 thread = new ThreadInfo();
1058                 thread.id = threadId;
1059             }
1060             if (thread.messageExpirationTime != message.getExpiresInSeconds()) {
1061                 thread.messageExpirationTime = message.getExpiresInSeconds();
1062                 threadStore.updateThread(thread);
1063             }
1064         }
1065         if (message.getAttachments().isPresent() && !ignoreAttachments) {
1066             for (SignalServiceAttachment attachment : message.getAttachments().get()) {
1067                 if (attachment.isPointer()) {
1068                     try {
1069                         retrieveAttachment(attachment.asPointer());
1070                     } catch (IOException | InvalidMessageException e) {
1071                         System.err.println("Failed to retrieve attachment (" + attachment.asPointer().getId() + "): " + e.getMessage());
1072                     }
1073                 }
1074             }
1075         }
1076     }
1077
1078     public void retryFailedReceivedMessages(ReceiveMessageHandler handler, boolean ignoreAttachments) {
1079         final File cachePath = new File(getMessageCachePath());
1080         if (!cachePath.exists()) {
1081             return;
1082         }
1083         for (final File dir : cachePath.listFiles()) {
1084             if (!dir.isDirectory()) {
1085                 continue;
1086             }
1087
1088             for (final File fileEntry : dir.listFiles()) {
1089                 if (!fileEntry.isFile()) {
1090                     continue;
1091                 }
1092                 SignalServiceEnvelope envelope;
1093                 try {
1094                     envelope = loadEnvelope(fileEntry);
1095                     if (envelope == null) {
1096                         continue;
1097                     }
1098                 } catch (IOException e) {
1099                     e.printStackTrace();
1100                     continue;
1101                 }
1102                 SignalServiceContent content = null;
1103                 if (!envelope.isReceipt()) {
1104                     try {
1105                         content = decryptMessage(envelope);
1106                     } catch (Exception e) {
1107                         continue;
1108                     }
1109                     handleMessage(envelope, content, ignoreAttachments);
1110                 }
1111                 save();
1112                 handler.handleMessage(envelope, content, null);
1113                 try {
1114                     Files.delete(fileEntry.toPath());
1115                 } catch (IOException e) {
1116                     System.out.println("Failed to delete cached message file “" + fileEntry + "”: " + e.getMessage());
1117                 }
1118             }
1119         }
1120     }
1121
1122     public void receiveMessages(long timeout, TimeUnit unit, boolean returnOnTimeout, boolean ignoreAttachments, ReceiveMessageHandler handler) throws IOException {
1123         retryFailedReceivedMessages(handler, ignoreAttachments);
1124         final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(serviceUrls, username, password, deviceId, signalingKey, USER_AGENT);
1125
1126         try {
1127             if (messagePipe == null) {
1128                 messagePipe = messageReceiver.createMessagePipe();
1129             }
1130
1131             while (true) {
1132                 SignalServiceEnvelope envelope;
1133                 SignalServiceContent content = null;
1134                 Exception exception = null;
1135                 final long now = new Date().getTime();
1136                 try {
1137                     envelope = messagePipe.read(timeout, unit, new SignalServiceMessagePipe.MessagePipeCallback() {
1138                         @Override
1139                         public void onMessage(SignalServiceEnvelope envelope) {
1140                             // store message on disk, before acknowledging receipt to the server
1141                             try {
1142                                 File cacheFile = getMessageCacheFile(envelope.getSource(), now, envelope.getTimestamp());
1143                                 storeEnvelope(envelope, cacheFile);
1144                             } catch (IOException e) {
1145                                 System.err.println("Failed to store encrypted message in disk cache, ignoring: " + e.getMessage());
1146                             }
1147                         }
1148                     });
1149                 } catch (TimeoutException e) {
1150                     if (returnOnTimeout)
1151                         return;
1152                     continue;
1153                 } catch (InvalidVersionException e) {
1154                     System.err.println("Ignoring error: " + e.getMessage());
1155                     continue;
1156                 }
1157                 if (!envelope.isReceipt()) {
1158                     try {
1159                         content = decryptMessage(envelope);
1160                     } catch (Exception e) {
1161                         exception = e;
1162                     }
1163                     handleMessage(envelope, content, ignoreAttachments);
1164                 }
1165                 save();
1166                 handler.handleMessage(envelope, content, exception);
1167                 if (exception == null || !(exception instanceof org.whispersystems.libsignal.UntrustedIdentityException)) {
1168                     File cacheFile = null;
1169                     try {
1170                         cacheFile = getMessageCacheFile(envelope.getSource(), now, envelope.getTimestamp());
1171                         Files.delete(cacheFile.toPath());
1172                     } catch (IOException e) {
1173                         System.out.println("Failed to delete cached message file “" + cacheFile + "”: " + e.getMessage());
1174                     }
1175                 }
1176             }
1177         } finally {
1178             if (messagePipe != null) {
1179                 messagePipe.shutdown();
1180                 messagePipe = null;
1181             }
1182         }
1183     }
1184
1185     private void handleMessage(SignalServiceEnvelope envelope, SignalServiceContent content, boolean ignoreAttachments) {
1186         if (content != null) {
1187             if (content.getDataMessage().isPresent()) {
1188                 SignalServiceDataMessage message = content.getDataMessage().get();
1189                 handleSignalServiceDataMessage(message, false, envelope.getSource(), username, ignoreAttachments);
1190             }
1191             if (content.getSyncMessage().isPresent()) {
1192                 SignalServiceSyncMessage syncMessage = content.getSyncMessage().get();
1193                 if (syncMessage.getSent().isPresent()) {
1194                     SignalServiceDataMessage message = syncMessage.getSent().get().getMessage();
1195                     handleSignalServiceDataMessage(message, true, envelope.getSource(), syncMessage.getSent().get().getDestination().get(), ignoreAttachments);
1196                 }
1197                 if (syncMessage.getRequest().isPresent()) {
1198                     RequestMessage rm = syncMessage.getRequest().get();
1199                     if (rm.isContactsRequest()) {
1200                         try {
1201                             sendContacts();
1202                         } catch (UntrustedIdentityException | IOException e) {
1203                             e.printStackTrace();
1204                         }
1205                     }
1206                     if (rm.isGroupsRequest()) {
1207                         try {
1208                             sendGroups();
1209                         } catch (UntrustedIdentityException | IOException e) {
1210                             e.printStackTrace();
1211                         }
1212                     }
1213                 }
1214                 if (syncMessage.getGroups().isPresent()) {
1215                     File tmpFile = null;
1216                     try {
1217                         tmpFile = Util.createTempFile();
1218                         DeviceGroupsInputStream s = new DeviceGroupsInputStream(retrieveAttachmentAsStream(syncMessage.getGroups().get().asPointer(), tmpFile));
1219                         DeviceGroup g;
1220                         while ((g = s.read()) != null) {
1221                             GroupInfo syncGroup = groupStore.getGroup(g.getId());
1222                             if (syncGroup == null) {
1223                                 syncGroup = new GroupInfo(g.getId());
1224                             }
1225                             if (g.getName().isPresent()) {
1226                                 syncGroup.name = g.getName().get();
1227                             }
1228                             syncGroup.members.addAll(g.getMembers());
1229                             syncGroup.active = g.isActive();
1230
1231                             if (g.getAvatar().isPresent()) {
1232                                 retrieveGroupAvatarAttachment(g.getAvatar().get(), syncGroup.groupId);
1233                             }
1234                             groupStore.updateGroup(syncGroup);
1235                         }
1236                     } catch (Exception e) {
1237                         e.printStackTrace();
1238                     } finally {
1239                         if (tmpFile != null) {
1240                             try {
1241                                 Files.delete(tmpFile.toPath());
1242                             } catch (IOException e) {
1243                                 System.out.println("Failed to delete temp file “" + tmpFile + "”: " + e.getMessage());
1244                             }
1245                         }
1246                     }
1247                     if (syncMessage.getBlockedList().isPresent()) {
1248                         // TODO store list of blocked numbers
1249                     }
1250                 }
1251                 if (syncMessage.getContacts().isPresent()) {
1252                     File tmpFile = null;
1253                     try {
1254                         tmpFile = Util.createTempFile();
1255                         final ContactsMessage contactsMessage = syncMessage.getContacts().get();
1256                         DeviceContactsInputStream s = new DeviceContactsInputStream(retrieveAttachmentAsStream(contactsMessage.getContactsStream().asPointer(), tmpFile));
1257                         if (contactsMessage.isComplete()) {
1258                             contactStore.clear();
1259                         }
1260                         DeviceContact c;
1261                         while ((c = s.read()) != null) {
1262                             ContactInfo contact = contactStore.getContact(c.getNumber());
1263                             if (contact == null) {
1264                                 contact = new ContactInfo();
1265                                 contact.number = c.getNumber();
1266                             }
1267                             if (c.getName().isPresent()) {
1268                                 contact.name = c.getName().get();
1269                             }
1270                             if (c.getColor().isPresent()) {
1271                                 contact.color = c.getColor().get();
1272                             }
1273                             contactStore.updateContact(contact);
1274
1275                             if (c.getAvatar().isPresent()) {
1276                                 retrieveContactAvatarAttachment(c.getAvatar().get(), contact.number);
1277                             }
1278                         }
1279                     } catch (Exception e) {
1280                         e.printStackTrace();
1281                     } finally {
1282                         if (tmpFile != null) {
1283                             try {
1284                                 Files.delete(tmpFile.toPath());
1285                             } catch (IOException e) {
1286                                 System.out.println("Failed to delete temp file “" + tmpFile + "”: " + e.getMessage());
1287                             }
1288                         }
1289                     }
1290                 }
1291             }
1292         }
1293     }
1294
1295     private SignalServiceEnvelope loadEnvelope(File file) throws IOException {
1296         try (FileInputStream f = new FileInputStream(file)) {
1297             DataInputStream in = new DataInputStream(f);
1298             int version = in.readInt();
1299             if (version != 1) {
1300                 return null;
1301             }
1302             int type = in.readInt();
1303             String source = in.readUTF();
1304             int sourceDevice = in.readInt();
1305             String relay = in.readUTF();
1306             long timestamp = in.readLong();
1307             byte[] content = null;
1308             int contentLen = in.readInt();
1309             if (contentLen > 0) {
1310                 content = new byte[contentLen];
1311                 in.readFully(content);
1312             }
1313             byte[] legacyMessage = null;
1314             int legacyMessageLen = in.readInt();
1315             if (legacyMessageLen > 0) {
1316                 legacyMessage = new byte[legacyMessageLen];
1317                 in.readFully(legacyMessage);
1318             }
1319             return new SignalServiceEnvelope(type, source, sourceDevice, relay, timestamp, legacyMessage, content);
1320         }
1321     }
1322
1323     private void storeEnvelope(SignalServiceEnvelope envelope, File file) throws IOException {
1324         try (FileOutputStream f = new FileOutputStream(file)) {
1325             try (DataOutputStream out = new DataOutputStream(f)) {
1326                 out.writeInt(1); // version
1327                 out.writeInt(envelope.getType());
1328                 out.writeUTF(envelope.getSource());
1329                 out.writeInt(envelope.getSourceDevice());
1330                 out.writeUTF(envelope.getRelay());
1331                 out.writeLong(envelope.getTimestamp());
1332                 if (envelope.hasContent()) {
1333                     out.writeInt(envelope.getContent().length);
1334                     out.write(envelope.getContent());
1335                 } else {
1336                     out.writeInt(0);
1337                 }
1338                 if (envelope.hasLegacyMessage()) {
1339                     out.writeInt(envelope.getLegacyMessage().length);
1340                     out.write(envelope.getLegacyMessage());
1341                 } else {
1342                     out.writeInt(0);
1343                 }
1344             }
1345         }
1346     }
1347
1348     public File getContactAvatarFile(String number) {
1349         return new File(avatarsPath, "contact-" + number);
1350     }
1351
1352     private File retrieveContactAvatarAttachment(SignalServiceAttachment attachment, String number) throws IOException, InvalidMessageException {
1353         createPrivateDirectories(avatarsPath);
1354         if (attachment.isPointer()) {
1355             SignalServiceAttachmentPointer pointer = attachment.asPointer();
1356             return retrieveAttachment(pointer, getContactAvatarFile(number), false);
1357         } else {
1358             SignalServiceAttachmentStream stream = attachment.asStream();
1359             return retrieveAttachment(stream, getContactAvatarFile(number));
1360         }
1361     }
1362
1363     public File getGroupAvatarFile(byte[] groupId) {
1364         return new File(avatarsPath, "group-" + Base64.encodeBytes(groupId).replace("/", "_"));
1365     }
1366
1367     private File retrieveGroupAvatarAttachment(SignalServiceAttachment attachment, byte[] groupId) throws IOException, InvalidMessageException {
1368         createPrivateDirectories(avatarsPath);
1369         if (attachment.isPointer()) {
1370             SignalServiceAttachmentPointer pointer = attachment.asPointer();
1371             return retrieveAttachment(pointer, getGroupAvatarFile(groupId), false);
1372         } else {
1373             SignalServiceAttachmentStream stream = attachment.asStream();
1374             return retrieveAttachment(stream, getGroupAvatarFile(groupId));
1375         }
1376     }
1377
1378     public File getAttachmentFile(long attachmentId) {
1379         return new File(attachmentsPath, attachmentId + "");
1380     }
1381
1382     private File retrieveAttachment(SignalServiceAttachmentPointer pointer) throws IOException, InvalidMessageException {
1383         createPrivateDirectories(attachmentsPath);
1384         return retrieveAttachment(pointer, getAttachmentFile(pointer.getId()), true);
1385     }
1386
1387     private File retrieveAttachment(SignalServiceAttachmentStream stream, File outputFile) throws IOException, InvalidMessageException {
1388         InputStream input = stream.getInputStream();
1389
1390         try (OutputStream output = new FileOutputStream(outputFile)) {
1391             byte[] buffer = new byte[4096];
1392             int read;
1393
1394             while ((read = input.read(buffer)) != -1) {
1395                 output.write(buffer, 0, read);
1396             }
1397         } catch (FileNotFoundException e) {
1398             e.printStackTrace();
1399             return null;
1400         }
1401         return outputFile;
1402     }
1403
1404     private File retrieveAttachment(SignalServiceAttachmentPointer pointer, File outputFile, boolean storePreview) throws IOException, InvalidMessageException {
1405         if (storePreview && pointer.getPreview().isPresent()) {
1406             File previewFile = new File(outputFile + ".preview");
1407             try (OutputStream output = new FileOutputStream(previewFile)) {
1408                 byte[] preview = pointer.getPreview().get();
1409                 output.write(preview, 0, preview.length);
1410             } catch (FileNotFoundException e) {
1411                 e.printStackTrace();
1412                 return null;
1413             }
1414         }
1415
1416         final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(serviceUrls, username, password, deviceId, signalingKey, USER_AGENT);
1417
1418         File tmpFile = Util.createTempFile();
1419         try (InputStream input = messageReceiver.retrieveAttachment(pointer, tmpFile, MAX_ATTACHMENT_SIZE)) {
1420             try (OutputStream output = new FileOutputStream(outputFile)) {
1421                 byte[] buffer = new byte[4096];
1422                 int read;
1423
1424                 while ((read = input.read(buffer)) != -1) {
1425                     output.write(buffer, 0, read);
1426                 }
1427             } catch (FileNotFoundException e) {
1428                 e.printStackTrace();
1429                 return null;
1430             }
1431         } finally {
1432             try {
1433                 Files.delete(tmpFile.toPath());
1434             } catch (IOException e) {
1435                 System.out.println("Failed to delete temp file “" + tmpFile + "”: " + e.getMessage());
1436             }
1437         }
1438         return outputFile;
1439     }
1440
1441     private InputStream retrieveAttachmentAsStream(SignalServiceAttachmentPointer pointer, File tmpFile) throws IOException, InvalidMessageException {
1442         final SignalServiceMessageReceiver messageReceiver = new SignalServiceMessageReceiver(serviceUrls, username, password, deviceId, signalingKey, USER_AGENT);
1443         return messageReceiver.retrieveAttachment(pointer, tmpFile, MAX_ATTACHMENT_SIZE);
1444     }
1445
1446     private String canonicalizeNumber(String number) throws InvalidNumberException {
1447         String localNumber = username;
1448         return PhoneNumberFormatter.formatNumber(number, localNumber);
1449     }
1450
1451     private SignalServiceAddress getPushAddress(String number) throws InvalidNumberException {
1452         String e164number = canonicalizeNumber(number);
1453         return new SignalServiceAddress(e164number);
1454     }
1455
1456     @Override
1457     public boolean isRemote() {
1458         return false;
1459     }
1460
1461     private void sendGroups() throws IOException, UntrustedIdentityException {
1462         File groupsFile = Util.createTempFile();
1463
1464         try {
1465             try (OutputStream fos = new FileOutputStream(groupsFile)) {
1466                 DeviceGroupsOutputStream out = new DeviceGroupsOutputStream(fos);
1467                 for (GroupInfo record : groupStore.getGroups()) {
1468                     out.write(new DeviceGroup(record.groupId, Optional.fromNullable(record.name),
1469                             new ArrayList<>(record.members), createGroupAvatarAttachment(record.groupId),
1470                             record.active));
1471                 }
1472             }
1473
1474             if (groupsFile.exists() && groupsFile.length() > 0) {
1475                 try (FileInputStream groupsFileStream = new FileInputStream(groupsFile)) {
1476                     SignalServiceAttachmentStream attachmentStream = SignalServiceAttachment.newStreamBuilder()
1477                             .withStream(groupsFileStream)
1478                             .withContentType("application/octet-stream")
1479                             .withLength(groupsFile.length())
1480                             .build();
1481
1482                     sendSyncMessage(SignalServiceSyncMessage.forGroups(attachmentStream));
1483                 }
1484             }
1485         } finally {
1486             try {
1487                 Files.delete(groupsFile.toPath());
1488             } catch (IOException e) {
1489                 System.out.println("Failed to delete temp file “" + groupsFile + "”: " + e.getMessage());
1490             }
1491         }
1492     }
1493
1494     private void sendContacts() throws IOException, UntrustedIdentityException {
1495         File contactsFile = Util.createTempFile();
1496
1497         try {
1498             try (OutputStream fos = new FileOutputStream(contactsFile)) {
1499                 DeviceContactsOutputStream out = new DeviceContactsOutputStream(fos);
1500                 for (ContactInfo record : contactStore.getContacts()) {
1501                     out.write(new DeviceContact(record.number, Optional.fromNullable(record.name),
1502                             createContactAvatarAttachment(record.number), Optional.fromNullable(record.color)));
1503                 }
1504             }
1505
1506             if (contactsFile.exists() && contactsFile.length() > 0) {
1507                 try (FileInputStream contactsFileStream = new FileInputStream(contactsFile)) {
1508                     SignalServiceAttachmentStream attachmentStream = SignalServiceAttachment.newStreamBuilder()
1509                             .withStream(contactsFileStream)
1510                             .withContentType("application/octet-stream")
1511                             .withLength(contactsFile.length())
1512                             .build();
1513
1514                     sendSyncMessage(SignalServiceSyncMessage.forContacts(new ContactsMessage(attachmentStream, true)));
1515                 }
1516             }
1517         } finally {
1518             try {
1519                 Files.delete(contactsFile.toPath());
1520             } catch (IOException e) {
1521                 System.out.println("Failed to delete temp file “" + contactsFile + "”: " + e.getMessage());
1522             }
1523         }
1524     }
1525
1526     public ContactInfo getContact(String number) {
1527         return contactStore.getContact(number);
1528     }
1529
1530     public GroupInfo getGroup(byte[] groupId) {
1531         return groupStore.getGroup(groupId);
1532     }
1533
1534     public Map<String, List<JsonIdentityKeyStore.Identity>> getIdentities() {
1535         return signalProtocolStore.getIdentities();
1536     }
1537
1538     public List<JsonIdentityKeyStore.Identity> getIdentities(String number) {
1539         return signalProtocolStore.getIdentities(number);
1540     }
1541
1542     /**
1543      * Trust this the identity with this fingerprint
1544      *
1545      * @param name        username of the identity
1546      * @param fingerprint Fingerprint
1547      */
1548     public boolean trustIdentityVerified(String name, byte[] fingerprint) {
1549         List<JsonIdentityKeyStore.Identity> ids = signalProtocolStore.getIdentities(name);
1550         if (ids == null) {
1551             return false;
1552         }
1553         for (JsonIdentityKeyStore.Identity id : ids) {
1554             if (!Arrays.equals(id.getIdentityKey().serialize(), fingerprint)) {
1555                 continue;
1556             }
1557
1558             signalProtocolStore.saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
1559             save();
1560             return true;
1561         }
1562         return false;
1563     }
1564
1565     /**
1566      * Trust this the identity with this safety number
1567      *
1568      * @param name         username of the identity
1569      * @param safetyNumber Safety number
1570      */
1571     public boolean trustIdentityVerifiedSafetyNumber(String name, String safetyNumber) {
1572         List<JsonIdentityKeyStore.Identity> ids = signalProtocolStore.getIdentities(name);
1573         if (ids == null) {
1574             return false;
1575         }
1576         for (JsonIdentityKeyStore.Identity id : ids) {
1577             if (!safetyNumber.equals(computeSafetyNumber(name, id.getIdentityKey()))) {
1578                 continue;
1579             }
1580
1581             signalProtocolStore.saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_VERIFIED);
1582             save();
1583             return true;
1584         }
1585         return false;
1586     }
1587
1588     /**
1589      * Trust all keys of this identity without verification
1590      *
1591      * @param name username of the identity
1592      */
1593     public boolean trustIdentityAllKeys(String name) {
1594         List<JsonIdentityKeyStore.Identity> ids = signalProtocolStore.getIdentities(name);
1595         if (ids == null) {
1596             return false;
1597         }
1598         for (JsonIdentityKeyStore.Identity id : ids) {
1599             if (id.getTrustLevel() == TrustLevel.UNTRUSTED) {
1600                 signalProtocolStore.saveIdentity(name, id.getIdentityKey(), TrustLevel.TRUSTED_UNVERIFIED);
1601             }
1602         }
1603         save();
1604         return true;
1605     }
1606
1607     public String computeSafetyNumber(String theirUsername, IdentityKey theirIdentityKey) {
1608         Fingerprint fingerprint = new NumericFingerprintGenerator(5200).createFor(username, getIdentity(), theirUsername, theirIdentityKey);
1609         return fingerprint.getDisplayableFingerprint().getDisplayText();
1610     }
1611 }