Fingerprint: Change the fingerprint format to be numeric instead of hex.

Thanks to @dschuermann for the suggestion. This makes it easier for
people of non-latin speaking cultures to compare the fingerprints.

Code is based off of Signal's fingerprint generation.

app/src/main/java/com/etesync/syncadapter/journalmanager/Crypto.java

@@ -3,6 +3,7 @@ package com.etesync.syncadapter.journalmanager;
 import android.support.annotation.NonNull;
 
 import com.etesync.syncadapter.App;
+import com.etesync.syncadapter.journalmanager.util.ByteUtil;
 import com.etesync.syncadapter.utils.Base64;
 
 import org.apache.commons.codec.Charsets;
@@ -38,6 +39,7 @@ import java.io.IOException;
 import java.math.BigInteger;
 import java.security.SecureRandom;
 import java.util.Arrays;
+import java.util.Locale;
 
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -118,8 +120,21 @@ public class Crypto {
 
         public static String getPrettyKeyFingerprint(byte[] pubkey) {
             byte[] fingerprint = Crypto.AsymmetricCryptoManager.getKeyFingerprint(pubkey);
-            String fingerprintString = Hex.toHexString(fingerprint).toLowerCase();
+            String spacing = "   ";
-            return fingerprintString.replaceAll("(.{4})", "$1   ").trim();
+            String ret = getEncodedChunk(fingerprint, 0) + spacing +
+                    getEncodedChunk(fingerprint, 4)  + spacing +
+                    getEncodedChunk(fingerprint, 8)  + spacing +
+                    getEncodedChunk(fingerprint, 12) + "\n" +
+                    getEncodedChunk(fingerprint, 16) + spacing +
+                    getEncodedChunk(fingerprint, 20) + spacing +
+                    getEncodedChunk(fingerprint, 24) + spacing +
+                    getEncodedChunk(fingerprint, 28);
+            return ret.trim();
+        }
+
+        private static String getEncodedChunk(byte[] hash, int offset) {
+            long chunk = ByteUtil.byteArray4ToLong(hash, offset) % 100000;
+            return String.format(Locale.getDefault(), "%05d", chunk);
         }
     }
 

app/src/main/java/com/etesync/syncadapter/journalmanager/util/ByteUtil.java

@@ -0,0 +1,248 @@
+/**
+ * Copyright (C) 2014-2016 Open Whisper Systems
+ *
+ * Licensed according to the LICENSE file in this repository.
+ */
+package com.etesync.syncadapter.journalmanager.util;
+
+import org.apache.commons.codec.binary.Hex;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.text.ParseException;
+
+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);
+    }
+  }
+
+  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)
+      throws ParseException
+  {
+    if (input == null || firstLength < 0 || secondLength < 0 || thirdLength < 0 ||
+        input.length < firstLength + secondLength + thirdLength)
+    {
+      throw new ParseException("Input too small: " + (input == null ? null : Hex.encodeHex(input)), 0);
+    }
+
+    byte[][] parts = new byte[3][];
+
+    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);
+
+    return parts;
+  }
+
+  public static byte[] trim(byte[] input, int length) {
+    byte[] result = new byte[length];
+    System.arraycopy(input, 0, result, 0, result.length);
+
+    return result;
+  }
+
+  public static byte[] copyFrom(byte[] input) {
+    byte[] output = new byte[input.length];
+    System.arraycopy(input, 0, output, 0, output.length);
+
+    return output;
+  }
+
+  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 byteArray5ToLong(byte[] bytes, int offset) {
+    return
+        ((bytes[offset]     & 0xffL) << 32) |
+        ((bytes[offset + 1] & 0xffL) << 24) |
+        ((bytes[offset + 2] & 0xffL) << 16) |
+        ((bytes[offset + 3] & 0xffL) << 8) |
+        ((bytes[offset + 4] & 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));
+  }
+
+}