Break out into a multi-module project

service/src/main/java/org/whispersystems/textsecuregcm/crypto/Curve.java

@@ -0,0 +1,98 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+import org.whispersystems.curve25519.Curve25519;
+import org.whispersystems.curve25519.Curve25519KeyPair;
+
+import java.security.InvalidKeyException;
+
+import static org.whispersystems.curve25519.Curve25519.BEST;
+
+public class Curve {
+
+  public  static final int DJB_TYPE   = 0x05;
+
+  public static ECKeyPair generateKeyPair() {
+    Curve25519KeyPair keyPair = Curve25519.getInstance(BEST).generateKeyPair();
+
+    return new ECKeyPair(new DjbECPublicKey(keyPair.getPublicKey()),
+                         new DjbECPrivateKey(keyPair.getPrivateKey()));
+  }
+
+  public static ECPublicKey decodePoint(byte[] bytes, int offset)
+      throws InvalidKeyException
+  {
+    if (bytes == null || bytes.length - offset < 1) {
+      throw new InvalidKeyException("No key type identifier");
+    }
+
+    int type = bytes[offset] & 0xFF;
+
+    switch (type) {
+      case Curve.DJB_TYPE:
+        if (bytes.length - offset < 33) {
+          throw new InvalidKeyException("Bad key length: " + bytes.length);
+        }
+
+        byte[] keyBytes = new byte[32];
+        System.arraycopy(bytes, offset+1, keyBytes, 0, keyBytes.length);
+        return new DjbECPublicKey(keyBytes);
+      default:
+        throw new InvalidKeyException("Bad key type: " + type);
+    }
+  }
+
+  public static ECPrivateKey decodePrivatePoint(byte[] bytes) {
+    return new DjbECPrivateKey(bytes);
+  }
+
+  public static byte[] calculateAgreement(ECPublicKey publicKey, ECPrivateKey privateKey)
+      throws InvalidKeyException
+  {
+    if (publicKey == null) {
+      throw new InvalidKeyException("public value is null");
+    }
+
+    if (privateKey == null) {
+      throw new InvalidKeyException("private value is null");
+    }
+
+    if (publicKey.getType() != privateKey.getType()) {
+      throw new InvalidKeyException("Public and private keys must be of the same type!");
+    }
+
+    if (publicKey.getType() == DJB_TYPE) {
+      return Curve25519.getInstance(BEST)
+                       .calculateAgreement(((DjbECPublicKey) publicKey).getPublicKey(),
+                                           ((DjbECPrivateKey) privateKey).getPrivateKey());
+    } else {
+      throw new InvalidKeyException("Unknown type: " + publicKey.getType());
+    }
+  }
+
+  public static byte[] calculateSignature(ECPrivateKey signingKey, byte[] message)
+      throws InvalidKeyException
+  {
+    if (signingKey == null || message == null) {
+      throw new InvalidKeyException("Values must not be null");
+    }
+
+    if (signingKey.getType() == DJB_TYPE) {
+      return Curve25519.getInstance(BEST)
+                       .calculateSignature(((DjbECPrivateKey) signingKey).getPrivateKey(), message);
+    } else {
+      throw new InvalidKeyException("Unknown type: " + signingKey.getType());
+    }
+  }
+
+  public static boolean verifySignature(ECPublicKey signingKey, byte[] message, byte[] signature)
+      throws InvalidKeyException
+  {
+    if (signingKey.getType() == DJB_TYPE) {
+      return Curve25519.getInstance(BEST)
+                       .verifySignature(((DjbECPublicKey) signingKey).getPublicKey(), message, signature);
+    } else {
+      throw new InvalidKeyException("Unknown type: " + signingKey.getType());
+    }
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/crypto/DjbECPrivateKey.java

@@ -0,0 +1,24 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+public class DjbECPrivateKey implements ECPrivateKey {
+
+  private final byte[] privateKey;
+
+  DjbECPrivateKey(byte[] privateKey) {
+    this.privateKey = privateKey;
+  }
+
+  @Override
+  public byte[] serialize() {
+    return privateKey;
+  }
+
+  @Override
+  public int getType() {
+    return Curve.DJB_TYPE;
+  }
+
+  public byte[] getPrivateKey() {
+    return privateKey;
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/crypto/DjbECPublicKey.java

@@ -0,0 +1,49 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+import org.whispersystems.textsecuregcm.util.ByteUtil;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+public class DjbECPublicKey implements ECPublicKey {
+
+  private final byte[] publicKey;
+
+  DjbECPublicKey(byte[] publicKey) {
+    this.publicKey = publicKey;
+  }
+
+  @Override
+  public byte[] serialize() {
+    byte[] type = {Curve.DJB_TYPE};
+    return ByteUtil.combine(type, publicKey);
+  }
+
+  @Override
+  public int getType() {
+    return Curve.DJB_TYPE;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other == null)                      return false;
+    if (!(other instanceof DjbECPublicKey)) return false;
+
+    DjbECPublicKey that = (DjbECPublicKey)other;
+    return Arrays.equals(this.publicKey, that.publicKey);
+  }
+
+  @Override
+  public int hashCode() {
+    return Arrays.hashCode(publicKey);
+  }
+
+  @Override
+  public int compareTo(ECPublicKey another) {
+    return new BigInteger(publicKey).compareTo(new BigInteger(((DjbECPublicKey)another).publicKey));
+  }
+
+  public byte[] getPublicKey() {
+    return publicKey;
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/crypto/ECKeyPair.java

@@ -0,0 +1,20 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+public class ECKeyPair {
+
+  private final ECPublicKey  publicKey;
+  private final ECPrivateKey privateKey;
+
+  ECKeyPair(ECPublicKey publicKey, ECPrivateKey privateKey) {
+    this.publicKey = publicKey;
+    this.privateKey = privateKey;
+  }
+
+  public ECPublicKey getPublicKey() {
+    return publicKey;
+  }
+
+  public ECPrivateKey getPrivateKey() {
+    return privateKey;
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/crypto/ECPrivateKey.java

@@ -0,0 +1,7 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+public interface ECPrivateKey {
+  public byte[] serialize();
+  public int getType();
+}
+

service/src/main/java/org/whispersystems/textsecuregcm/crypto/ECPublicKey.java

@@ -0,0 +1,10 @@
+package org.whispersystems.textsecuregcm.crypto;
+
+public interface ECPublicKey extends Comparable<ECPublicKey> {
+
+  public static final int KEY_SIZE = 33;
+
+  public byte[] serialize();
+
+  public int getType();
+}