Break out into a multi-module project

service/src/main/java/org/whispersystems/textsecuregcm/util/BlockingThreadPoolExecutor.java

@@ -0,0 +1,37 @@
+package org.whispersystems.textsecuregcm.util;
+
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class BlockingThreadPoolExecutor extends ThreadPoolExecutor {
+
+  private final Semaphore semaphore;
+
+  public BlockingThreadPoolExecutor(int threads, int bound) {
+    super(threads, threads, 1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+    this.semaphore = new Semaphore(bound);
+  }
+
+  @Override
+  public void execute(Runnable task) {
+    semaphore.acquireUninterruptibly();
+
+    try {
+      super.execute(task);
+    } catch (Throwable t) {
+      semaphore.release();
+      throw new RuntimeException(t);
+    }
+  }
+
+  @Override
+  protected void afterExecute(Runnable r, Throwable t) {
+    semaphore.release();
+  }
+
+  public int getSize() {
+    return ((LinkedBlockingQueue)getQueue()).size();
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/ByteArrayAdapter.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+
+import java.io.IOException;
+
+public class ByteArrayAdapter {
+
+  public static class Serializing extends JsonSerializer<byte[]> {
+    @Override
+    public void serialize(byte[] bytes, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
+        throws IOException, JsonProcessingException
+    {
+      jsonGenerator.writeString(Base64.encodeBytesWithoutPadding(bytes));
+    }
+  }
+
+  public static class Deserializing extends JsonDeserializer<byte[]> {
+    @Override
+    public byte[] deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
+        throws IOException, JsonProcessingException
+    {
+      return Base64.decodeWithoutPadding(jsonParser.getValueAsString());
+    }
+  }
+}
+

service/src/main/java/org/whispersystems/textsecuregcm/util/ByteUtil.java

@@ -0,0 +1,21 @@
+package org.whispersystems.textsecuregcm.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+public class ByteUtil {
+
+  public static byte[] combine(byte[]... elements) {
+    try {
+      ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+      for (byte[] element : elements) {
+        baos.write(element);
+      }
+
+      return baos.toByteArray();
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/CircuitBreakerUtil.java

@@ -0,0 +1,37 @@
+package org.whispersystems.textsecuregcm.util;
+
+import com.codahale.metrics.Meter;
+import com.codahale.metrics.MetricRegistry;
+
+import static com.codahale.metrics.MetricRegistry.name;
+import io.github.resilience4j.circuitbreaker.CircuitBreaker;
+import io.github.resilience4j.retry.AsyncRetry;
+import io.github.resilience4j.retry.Retry;
+
+public class CircuitBreakerUtil {
+
+  public static void registerMetrics(MetricRegistry metricRegistry, CircuitBreaker circuitBreaker, Class<?> clazz) {
+    Meter successMeter     = metricRegistry.meter(name(clazz, circuitBreaker.getName(), "success"    ));
+    Meter failureMeter     = metricRegistry.meter(name(clazz, circuitBreaker.getName(), "failure"    ));
+    Meter unpermittedMeter = metricRegistry.meter(name(clazz, circuitBreaker.getName(), "unpermitted"));
+
+    metricRegistry.gauge(name(clazz, circuitBreaker.getName(), "state"), () -> ()-> circuitBreaker.getState().getOrder());
+
+    circuitBreaker.getEventPublisher().onSuccess(event -> successMeter.mark());
+    circuitBreaker.getEventPublisher().onError(event -> failureMeter.mark());
+    circuitBreaker.getEventPublisher().onCallNotPermitted(event -> unpermittedMeter.mark());
+  }
+
+  public static void registerMetrics(MetricRegistry metricRegistry, Retry retry, Class<?> clazz) {
+    Meter successMeter      = metricRegistry.meter(name(clazz, retry.getName(), "success"      ));
+    Meter retryMeter        = metricRegistry.meter(name(clazz, retry.getName(), "retry"        ));
+    Meter errorMeter        = metricRegistry.meter(name(clazz, retry.getName(), "error"        ));
+    Meter ignoredErrorMeter = metricRegistry.meter(name(clazz, retry.getName(), "ignored_error"));
+
+    retry.getEventPublisher().onSuccess(event -> successMeter.mark());
+    retry.getEventPublisher().onRetry(event -> retryMeter.mark());
+    retry.getEventPublisher().onError(event -> errorMeter.mark());
+    retry.getEventPublisher().onIgnoredError(event -> ignoredErrorMeter.mark());
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/Constants.java

@@ -0,0 +1,7 @@
+package org.whispersystems.textsecuregcm.util;
+
+public class Constants {
+
+  public static final String METRICS_NAME = "textsecure";
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/Conversions.java

@@ -0,0 +1,180 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+public class Conversions {
+
+  public static byte intsToByteHighAndLow(int highValue, int lowValue) {
+    return (byte)((highValue << 4 | lowValue) & 0xFF);
+  }
+
+  public static int highBitsToInt(byte value) {
+    return (value & 0xFF) >> 4;
+  }
+
+  public static int lowBitsToInt(byte value) {
+    return (value & 0xF);
+  }
+
+  public static int highBitsToMedium(int value) {
+    return (value >> 12);
+  }
+
+  public static int lowBitsToMedium(int value) {
+    return (value & 0xFFF);
+  }
+
+  public static byte[] shortToByteArray(int value) {
+    byte[] bytes = new byte[2];
+    shortToByteArray(bytes, 0, value);
+    return bytes;
+  }
+
+  public static int shortToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset+1] = (byte)value;
+    bytes[offset]   = (byte)(value >> 8);
+    return 2;
+  }
+
+  public static int shortToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset]   = (byte)value;
+    bytes[offset+1] = (byte)(value >> 8);
+    return 2;
+  }
+
+  public static byte[] mediumToByteArray(int value) {
+    byte[] bytes = new byte[3];
+    mediumToByteArray(bytes, 0, value);
+    return bytes;
+  }
+
+  public static int mediumToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset + 2] = (byte)value;
+    bytes[offset + 1] = (byte)(value >> 8);
+    bytes[offset]     = (byte)(value >> 16);
+    return 3;
+  }
+
+  public static byte[] intToByteArray(int value) {
+    byte[] bytes = new byte[4];
+    intToByteArray(bytes, 0, value);
+    return bytes;
+  }
+
+  public static int intToByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset + 3] = (byte)value;
+    bytes[offset + 2] = (byte)(value >> 8);
+    bytes[offset + 1] = (byte)(value >> 16);
+    bytes[offset]     = (byte)(value >> 24);
+    return 4;
+  }
+
+  public static int intToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+    bytes[offset]   = (byte)value;
+    bytes[offset+1] = (byte)(value >> 8);
+    bytes[offset+2] = (byte)(value >> 16);
+    bytes[offset+3] = (byte)(value >> 24);
+    return 4;
+  }
+
+  public static byte[] longToByteArray(long l) {
+    byte[] bytes = new byte[8];
+    longToByteArray(bytes, 0, l);
+    return bytes;
+  }
+
+  public static int longToByteArray(byte[] bytes, int offset, long value) {
+    bytes[offset + 7] = (byte)value;
+    bytes[offset + 6] = (byte)(value >> 8);
+    bytes[offset + 5] = (byte)(value >> 16);
+    bytes[offset + 4] = (byte)(value >> 24);
+    bytes[offset + 3] = (byte)(value >> 32);
+    bytes[offset + 2] = (byte)(value >> 40);
+    bytes[offset + 1] = (byte)(value >> 48);
+    bytes[offset]     = (byte)(value >> 56);
+    return 8;
+  }
+
+  public static int longTo4ByteArray(byte[] bytes, int offset, long value) {
+    bytes[offset + 3] = (byte)value;
+    bytes[offset + 2] = (byte)(value >> 8);
+    bytes[offset + 1] = (byte)(value >> 16);
+    bytes[offset + 0] = (byte)(value >> 24);
+    return 4;
+  }
+
+  public static int byteArrayToShort(byte[] bytes) {
+    return byteArrayToShort(bytes, 0);
+  }
+
+  public static int byteArrayToShort(byte[] bytes, int offset) {
+    return
+      (bytes[offset] & 0xff) << 8 | (bytes[offset + 1] & 0xff);
+  }
+
+  // The SSL patented 3-byte Value.
+  public static int byteArrayToMedium(byte[] bytes, int offset) {
+    return
+      (bytes[offset]     & 0xff) << 16 |
+      (bytes[offset + 1] & 0xff) << 8  |
+      (bytes[offset + 2] & 0xff);
+  }
+
+  public static int byteArrayToInt(byte[] bytes) {
+    return byteArrayToInt(bytes, 0);
+  }
+
+  public static int byteArrayToInt(byte[] bytes, int offset)  {
+    return
+      (bytes[offset]     & 0xff) << 24 |
+      (bytes[offset + 1] & 0xff) << 16 |
+      (bytes[offset + 2] & 0xff) << 8  |
+      (bytes[offset + 3] & 0xff);
+  }
+
+  public static int byteArrayToIntLittleEndian(byte[] bytes, int offset) {
+    return
+      (bytes[offset + 3] & 0xff) << 24 |
+      (bytes[offset + 2] & 0xff) << 16 |
+      (bytes[offset + 1] & 0xff) << 8  |
+      (bytes[offset]     & 0xff);
+  }
+
+  public static long byteArrayToLong(byte[] bytes) {
+    return byteArrayToLong(bytes, 0);
+  }
+
+  public static long byteArray4ToLong(byte[] bytes, int offset) {
+    return
+        ((bytes[offset + 0] & 0xffL) << 24) |
+        ((bytes[offset + 1] & 0xffL) << 16) |
+        ((bytes[offset + 2] & 0xffL) << 8)  |
+        ((bytes[offset + 3] & 0xffL));
+  }
+
+  public static long byteArrayToLong(byte[] bytes, int offset) {
+    return
+      ((bytes[offset]     & 0xffL) << 56) |
+      ((bytes[offset + 1] & 0xffL) << 48) |
+      ((bytes[offset + 2] & 0xffL) << 40) |
+      ((bytes[offset + 3] & 0xffL) << 32) |
+      ((bytes[offset + 4] & 0xffL) << 24) |
+      ((bytes[offset + 5] & 0xffL) << 16) |
+      ((bytes[offset + 6] & 0xffL) << 8)  |
+      ((bytes[offset + 7] & 0xffL));
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/ExecutorUtils.java

@@ -0,0 +1,21 @@
+package org.whispersystems.textsecuregcm.util;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class ExecutorUtils {
+
+  public static Executor newFixedThreadBoundedQueueExecutor(int threadCount, int queueSize) {
+    ThreadPoolExecutor executor = new ThreadPoolExecutor(threadCount, threadCount,
+                                                         Long.MAX_VALUE, TimeUnit.NANOSECONDS,
+                                                         new ArrayBlockingQueue<>(queueSize),
+                                                         new ThreadPoolExecutor.AbortPolicy());
+
+    executor.prestartAllCoreThreads();
+
+    return executor;
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/Hex.java

@@ -0,0 +1,109 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+/**
+ * Utility for generating hex dumps a la hexl-mode in emacs.
+ */
+public class Hex {
+
+  private final static int HEX_DIGITS_START = 10;
+  private final static int ASCII_TEXT_START = HEX_DIGITS_START + (16*2 + (16/2));
+
+  final static String EOL = System.getProperty("line.separator");
+
+  private final static char[] HEX_DIGITS = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+  };
+
+  public static String toString(byte[] bytes) {
+    return toString(bytes, 0, bytes.length);
+  }
+
+  public static String toString(byte[] bytes, int offset, int length) {
+    StringBuffer buf = new StringBuffer();
+    for (int i = 0; i < length; i++) {
+      appendHexChar(buf, bytes[offset + i]);
+      buf.append(' ');
+    }
+    return buf.toString();
+  }
+
+  public static String dump(byte[] bytes) {
+    return dump(bytes, 0, bytes.length);
+  }
+
+  public static String dump(byte[] bytes, int offset, int length) {
+    StringBuffer buf = new StringBuffer();
+    int lines = ((length - 1) / 16) + 1;
+    int lineOffset;
+    int lineLength;
+
+    for (int i = 0; i < lines; i++) {
+      lineOffset = (i * 16) + offset;
+      lineLength = Math.min(16, (length - (i * 16)));
+      appendDumpLine(buf, i, bytes, lineOffset, lineLength);
+      buf.append(EOL);
+    }
+
+    return buf.toString();
+  }
+
+  private static void appendDumpLine(StringBuffer buf, int line,
+                                     byte[] bytes, int lineOffset,
+                                     int lineLength)
+  {
+    buf.append(HEX_DIGITS[(line >> 28) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 24) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 20) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 16) & 0xf]);
+    buf.append(HEX_DIGITS[(line >> 12) & 0xf]);
+    buf.append(HEX_DIGITS[(line >>  8) & 0xf]);
+    buf.append(HEX_DIGITS[(line >>  4) & 0xf]);
+    buf.append(HEX_DIGITS[(line      ) & 0xf]);
+    buf.append(": ");
+
+    for (int i = 0; i < 16; i++) {
+      int idx = i + lineOffset;
+      if (i < lineLength) {
+        int b = bytes[idx];
+        appendHexChar(buf, b);
+      } else {
+        buf.append("  ");
+      }
+      if ((i % 2) == 1) {
+        buf.append(' ');
+      }
+    }
+
+    for (int i = 0; i < 16 && i < lineLength; i++) {
+      int idx = i + lineOffset;
+      int b = bytes[idx];
+      if (b >= 0x20 && b <= 0x7e) {
+        buf.append((char)b);
+      } else {
+        buf.append('.');
+      }
+    }
+  }
+
+  private static void appendHexChar(StringBuffer buf, int b) {
+    buf.append(HEX_DIGITS[(b >> 4) & 0xf]);
+    buf.append(HEX_DIGITS[b & 0xf]);
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/IterablePair.java

@@ -0,0 +1,59 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class IterablePair <T1, T2> implements Iterable<Pair<T1,T2>> {
+  private final List<T1> first;
+  private final List<T2> second;
+
+  public IterablePair(List<T1> first, List<T2> second) {
+    this.first = first;
+    this.second = second;
+  }
+
+  @Override
+  public Iterator<Pair<T1, T2>> iterator(){
+    return new ParallelIterator<>( first.iterator(), second.iterator() );
+  }
+
+  public static class ParallelIterator <T1, T2> implements Iterator<Pair<T1, T2>> {
+
+    private final Iterator<T1> it1;
+    private final Iterator<T2> it2;
+
+    public ParallelIterator(Iterator<T1> it1, Iterator<T2> it2) {
+      this.it1 = it1; this.it2 = it2;
+    }
+
+    @Override
+    public boolean hasNext() { return it1.hasNext() && it2.hasNext(); }
+
+    @Override
+    public Pair<T1, T2> next() {
+      return new Pair<>(it1.next(), it2.next());
+    }
+
+    @Override
+    public void remove(){
+      it1.remove();
+      it2.remove();
+    }
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/Pair.java

@@ -0,0 +1,47 @@
+/**
+ * Copyright (C) 2014 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+import static com.google.common.base.Objects.equal;
+
+public class Pair<T1, T2> {
+  private final T1 v1;
+  private final T2 v2;
+
+  public Pair(T1 v1, T2 v2) {
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+
+  public T1 first(){
+    return v1;
+  }
+
+  public T2 second(){
+    return v2;
+  }
+
+  public boolean equals(Object o) {
+    return o instanceof Pair &&
+        equal(((Pair) o).first(), first()) &&
+        equal(((Pair) o).second(), second());
+  }
+
+  public int hashCode() {
+    return first().hashCode() ^ second().hashCode();
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/SystemMapper.java

@@ -0,0 +1,22 @@
+package org.whispersystems.textsecuregcm.util;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class SystemMapper {
+
+  private static final ObjectMapper mapper = new ObjectMapper();
+
+  static {
+    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
+    mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
+    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+  }
+
+  public static ObjectMapper getMapper() {
+    return mapper;
+  }
+
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/Util.java

@@ -0,0 +1,176 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Util {
+
+  private static final Pattern COUNTRY_CODE_PATTERN = Pattern.compile("^\\+([17]|2[07]|3[0123469]|4[013456789]|5[12345678]|6[0123456]|8[1246]|9[0123458]|\\d{3})");
+
+  public static byte[] getContactToken(String number) {
+    try {
+      MessageDigest digest    = MessageDigest.getInstance("SHA1");
+      byte[]        result    = digest.digest(number.getBytes());
+      byte[]        truncated = Util.truncate(result, 10);
+
+      return truncated;
+    } catch (NoSuchAlgorithmException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static String getEncodedContactToken(String number) {
+    return Base64.encodeBytesWithoutPadding(getContactToken(number));
+  }
+
+  public static boolean isValidNumber(String number) {
+    return number.matches("^\\+[0-9]+") && PhoneNumberUtil.getInstance().isPossibleNumber(number, null);
+  }
+
+  public static String getCountryCode(String number) {
+    Matcher matcher = COUNTRY_CODE_PATTERN.matcher(number);
+
+    if (matcher.find()) return matcher.group(1);
+    else                return "0";
+  }
+
+  public static String getNumberPrefix(String number) {
+    String countryCode  = getCountryCode(number);
+    int    remaining    = number.length() - (1 + countryCode.length());
+    int    prefixLength = Math.min(4, remaining);
+
+    return number.substring(0, 1 + countryCode.length() + prefixLength);
+  }
+
+  public static String encodeFormParams(Map<String, String> params) {
+    try {
+      StringBuffer buffer = new StringBuffer();
+
+      for (String key : params.keySet()) {
+        buffer.append(String.format("%s=%s",
+                                    URLEncoder.encode(key, "UTF-8"),
+                                    URLEncoder.encode(params.get(key), "UTF-8")));
+        buffer.append("&");
+      }
+
+      buffer.deleteCharAt(buffer.length()-1);
+      return buffer.toString();
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static boolean isEmpty(String param) {
+    return param == null || param.length() == 0;
+  }
+
+  public static byte[] combine(byte[] one, byte[] two, byte[] three, byte[] four) {
+    byte[] combined = new byte[one.length + two.length + three.length + four.length];
+    System.arraycopy(one, 0, combined, 0, one.length);
+    System.arraycopy(two, 0, combined, one.length, two.length);
+    System.arraycopy(three, 0, combined, one.length + two.length, three.length);
+    System.arraycopy(four, 0, combined, one.length + two.length + three.length, four.length);
+
+    return combined;
+  }
+
+  public static byte[] truncate(byte[] element, int length) {
+    byte[] result = new byte[length];
+    System.arraycopy(element, 0, result, 0, result.length);
+
+    return result;
+  }
+
+
+  public static byte[][] split(byte[] input, int firstLength, int secondLength) {
+    byte[][] parts = new byte[2][];
+
+    parts[0] = new byte[firstLength];
+    System.arraycopy(input, 0, parts[0], 0, firstLength);
+
+    parts[1] = new byte[secondLength];
+    System.arraycopy(input, firstLength, parts[1], 0, secondLength);
+
+    return parts;
+  }
+
+  public static byte[][] split(byte[] input, int firstLength, int secondLength, int thirdLength, int fourthLength) {
+    byte[][] parts = new byte[4][];
+
+    parts[0] = new byte[firstLength];
+    System.arraycopy(input, 0, parts[0], 0, firstLength);
+
+    parts[1] = new byte[secondLength];
+    System.arraycopy(input, firstLength, parts[1], 0, secondLength);
+
+    parts[2] = new byte[thirdLength];
+    System.arraycopy(input, firstLength + secondLength, parts[2], 0, thirdLength);
+
+    parts[3] = new byte[fourthLength];
+    System.arraycopy(input, firstLength + secondLength + thirdLength, parts[3], 0, fourthLength);
+
+    return parts;
+  }
+
+  public static byte[] generateSecretBytes(int size) {
+    byte[] data = new byte[size];
+    new SecureRandom().nextBytes(data);
+    return data;
+  }
+
+  public static void sleep(long i) {
+    try {
+      Thread.sleep(i);
+    } catch (InterruptedException ie) {}
+  }
+
+  public static void wait(Object object) {
+    try {
+      object.wait();
+    } catch (InterruptedException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static void wait(Object object, long timeoutMs) {
+    try {
+      object.wait(timeoutMs);
+    } catch (InterruptedException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static int hashCode(Object... objects) {
+    return Arrays.hashCode(objects);
+  }
+
+  public static long todayInMillis() {
+    return TimeUnit.DAYS.toMillis(TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis()));
+  }
+}

service/src/main/java/org/whispersystems/textsecuregcm/util/VerificationCode.java

@@ -0,0 +1,79 @@
+/**
+ * Copyright (C) 2013 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.textsecuregcm.util;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.google.common.annotations.VisibleForTesting;
+
+public class VerificationCode {
+
+  @JsonProperty
+  private String verificationCode;
+  @JsonIgnore
+  private String verificationCodeDisplay;
+  @JsonIgnore
+  private String verificationCodeSpeech;
+
+  @VisibleForTesting VerificationCode() {}
+
+  public VerificationCode(int verificationCode) {
+    this(verificationCode + "");
+  }
+
+  public VerificationCode(String verificationCode) {
+    this.verificationCode        = verificationCode;
+    this.verificationCodeDisplay = this.verificationCode.substring(0, 3) + "-" + this.verificationCode.substring(3, 6);
+    this.verificationCodeSpeech  = delimit(verificationCode + "");
+  }
+
+  public String getVerificationCode() {
+    return verificationCode;
+  }
+
+  public String getVerificationCodeDisplay() {
+    return verificationCodeDisplay;
+  }
+
+  public String getVerificationCodeSpeech() {
+    return verificationCodeSpeech;
+  }
+
+  private String delimit(String code) {
+    String delimited = "";
+
+    for (int i=0;i<code.length();i++) {
+      delimited += code.charAt(i);
+
+      if (i != code.length() - 1)
+        delimited += ',';
+    }
+
+    return delimited;
+  }
+
+  @VisibleForTesting public boolean equals(Object o) {
+    return o instanceof VerificationCode && verificationCode.equals(((VerificationCode) o).verificationCode);
+  }
+
+  public int hashCode() {
+    return Integer.parseInt(verificationCode);
+  }
+}