Integrate libaxolotl async storage changes

* Session records are now opaque strings, so treat them that way:
  - no more cross checking identity key and session records
  - Move hasOpenSession to axolotl wrapper
  - Remote registration ids must be fetched async'ly via protocol wrapper
* Implement async AxolotlStore using textsecure.storage
* Add some db stores and move prekeys and signed keys to indexeddb
* Add storage tests
* Rename identityKey storage key from libaxolotl25519KeyidentityKey to
  simply identityKey, since it's no longer hardcoded in libaxolotl
* Rework registration and key-generation, keeping logic in libtextsecure
  and rendering in options.js.
* Remove key_worker since workers are handled at the libaxolotl level
  now

libtextsecure/test/generate_keys_test.js

@@ -0,0 +1,181 @@
+/* vim: ts=4:sw=4
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+'use strict';
+
+describe("Key generation", function() {
+    var count = 10;
+    this.timeout(count*1000);
+
+    function validateStoredKeyPair(keyPair) {
+        /* Ensure the keypair matches the format used internally by libaxolotl */
+        assert.isObject(keyPair, 'Stored keyPair is not an object');
+        assert.instanceOf(keyPair.pubKey, ArrayBuffer);
+        assert.instanceOf(keyPair.privKey, ArrayBuffer);
+        assert.strictEqual(keyPair.pubKey.byteLength, 33);
+        assert.strictEqual(new Uint8Array(keyPair.pubKey)[0], 5);
+        assert.strictEqual(keyPair.privKey.byteLength, 32);
+    }
+    function itStoresPreKey(keyId) {
+        it('prekey ' + keyId + ' is valid', function(done) {
+            return textsecure.storage.axolotl.getPreKey(keyId).then(function(keyPair) {
+                validateStoredKeyPair(keyPair);
+            }).then(done,done);
+        });
+    }
+    function itStoresSignedPreKey(keyId) {
+        it('signed prekey ' + keyId + ' is valid', function(done) {
+            return textsecure.storage.axolotl.getSignedPreKey(keyId).then(function(keyPair) {
+                validateStoredKeyPair(keyPair);
+            }).then(done,done);
+        });
+    }
+    function validateResultKey(resultKey) {
+        return textsecure.storage.axolotl.getPreKey(resultKey.keyId).then(function(keyPair) {
+            assertEqualArrayBuffers(resultKey.publicKey, keyPair.pubKey);
+        });
+    }
+    function validateResultSignedKey(resultSignedKey) {
+        return textsecure.storage.axolotl.getSignedPreKey(resultSignedKey.keyId).then(function(keyPair) {
+            assertEqualArrayBuffers(resultSignedKey.publicKey, keyPair.pubKey);
+        });
+    }
+
+    before(function(done) {
+        localStorage.clear();
+        axolotl.util.generateIdentityKeyPair().then(function(keyPair) {
+            return textsecure.storage.axolotl.put('identityKey', keyPair);
+        }).then(done, done);
+    });
+
+    describe('the first time', function() {
+        var result;
+        /* result should have this format
+         * {
+         *   preKeys: [ { keyId, publicKey }, ... ],
+         *   signedPreKey: { keyId, publicKey, signature },
+         *   identityKey: <ArrayBuffer>
+         * }
+         */
+        before(function(done) {
+            generateKeys(count).then(function(res) {
+                result = res;
+            }).then(done,done);
+        });
+        for (var i = 1; i <= count; i++) {
+            itStoresPreKey(i);
+        }
+        itStoresSignedPreKey(1);
+
+        it('result contains ' + count + ' preKeys', function() {
+            assert.isArray(result.preKeys);
+            assert.lengthOf(result.preKeys, count);
+            for (var i = 0; i < count; i++) {
+                assert.isObject(result.preKeys[i]);
+            }
+        });
+        it('result contains the correct keyIds', function() {
+            for (var i = 0; i < count; i++) {
+                assert.strictEqual(result.preKeys[i].keyId, i+1);
+            }
+        });
+        it('result contains the correct public keys', function(done) {
+            Promise.all(result.preKeys.map(validateResultKey)).then(function() {
+                done();
+            }).catch(done);
+        });
+        it('returns a signed prekey', function(done) {
+            assert.strictEqual(result.signedPreKey.keyId, 1);
+            assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
+            validateResultSignedKey(result.signedPreKey).then(done,done);
+        });
+    });
+    describe('the second time', function() {
+        var result;
+        before(function(done) {
+            generateKeys(count).then(function(res) {
+                result = res;
+            }).then(done,done);
+        });
+        for (var i = 1; i <= 2*count; i++) {
+            itStoresPreKey(i);
+        }
+        itStoresSignedPreKey(1);
+        itStoresSignedPreKey(2);
+        it('result contains ' + count + ' preKeys', function() {
+            assert.isArray(result.preKeys);
+            assert.lengthOf(result.preKeys, count);
+            for (var i = 0; i < count; i++) {
+                assert.isObject(result.preKeys[i]);
+            }
+        });
+        it('result contains the correct keyIds', function() {
+            for (var i = 1; i <= count; i++) {
+                assert.strictEqual(result.preKeys[i-1].keyId, i+count);
+            }
+        });
+        it('result contains the correct public keys', function(done) {
+            Promise.all(result.preKeys.map(validateResultKey)).then(function() {
+                done();
+            }).catch(done);
+        });
+        it('returns a signed prekey', function(done) {
+            assert.strictEqual(result.signedPreKey.keyId, 2);
+            assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
+            validateResultSignedKey(result.signedPreKey).then(done,done);
+        });
+    });
+    describe('the third time', function() {
+        var result;
+        before(function(done) {
+            generateKeys(count).then(function(res) {
+                result = res;
+            }).then(done,done);
+        });
+        for (var i = 1; i <= 3*count; i++) {
+            itStoresPreKey(i);
+        }
+        itStoresSignedPreKey(2);
+        itStoresSignedPreKey(3);
+        it('result contains ' + count + ' preKeys', function() {
+            assert.isArray(result.preKeys);
+            assert.lengthOf(result.preKeys, count);
+            for (var i = 0; i < count; i++) {
+                assert.isObject(result.preKeys[i]);
+            }
+        });
+        it('result contains the correct keyIds', function() {
+            for (var i = 1; i <= count; i++) {
+                assert.strictEqual(result.preKeys[i-1].keyId, i+2*count);
+            }
+        });
+        it('result contains the correct public keys', function(done) {
+            Promise.all(result.preKeys.map(validateResultKey)).then(function() {
+                done();
+            }).catch(done);
+        });
+        it('result contains a signed prekey', function(done) {
+            assert.strictEqual(result.signedPreKey.keyId, 3);
+            assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
+            validateResultSignedKey(result.signedPreKey).then(done,done);
+        });
+        it('deletes signed key 1', function() {
+            textsecure.storage.axolotl.getSignedPreKey(1).then(function(keyPair) {
+                assert.isUndefined(keyPair);
+            });
+        });
+    });
+});