signal-desktop/libtextsecure/account_manager.js

/*
 * vim: ts=4:sw=4:expandtab
 */


;(function () {
    'use strict';
    window.textsecure = window.textsecure || {};

    var ARCHIVE_AGE = 7 * 24 * 60 * 60 * 1000;

    function AccountManager(url, username, password) {
        this.server = new TextSecureServer(url, username, password);
        this.pending = Promise.resolve();
    }

    function getNumber(numberId) {
        if (!numberId || !numberId.length) {
            return numberId;
        }

        var parts = numberId.split('.');
        if (!parts.length) {
            return numberId;
        }

        return parts[0];
    }

    AccountManager.prototype = new textsecure.EventTarget();
    AccountManager.prototype.extend({
        constructor: AccountManager,
        requestVoiceVerification: function(number) {
            return this.server.requestVerificationVoice(number);
        },
        requestSMSVerification: function(number) {
            return this.server.requestVerificationSMS(number);
        },
        registerSingleDevice: function(number, verificationCode) {
            var registerKeys = this.server.registerKeys.bind(this.server);
            var createAccount = this.createAccount.bind(this);
            var clearSessionsAndPreKeys = this.clearSessionsAndPreKeys.bind(this);
            var generateKeys = this.generateKeys.bind(this, 100);
            var confirmKeys = this.confirmKeys.bind(this);
            var registrationDone = this.registrationDone.bind(this);
            return this.queueTask(function() {
                return libsignal.KeyHelper.generateIdentityKeyPair().then(function(identityKeyPair) {
                    var profileKey = textsecure.crypto.getRandomBytes(32);
                    return createAccount(number, verificationCode, identityKeyPair, profileKey)
                        .then(clearSessionsAndPreKeys)
                        .then(generateKeys)
                        .then(function(keys) {
                            return registerKeys(keys).then(function() {
                                return confirmKeys(keys);
                            });
                        })
                        .then(registrationDone);
                });
            });
        },
        registerSecondDevice: function(setProvisioningUrl, confirmNumber, progressCallback) {
            var createAccount = this.createAccount.bind(this);
            var clearSessionsAndPreKeys = this.clearSessionsAndPreKeys.bind(this);
            var generateKeys = this.generateKeys.bind(this, 100, progressCallback);
            var confirmKeys = this.confirmKeys.bind(this);
            var registrationDone = this.registrationDone.bind(this);
            var registerKeys = this.server.registerKeys.bind(this.server);
            var getSocket = this.server.getProvisioningSocket.bind(this.server);
            var queueTask = this.queueTask.bind(this);
            var provisioningCipher = new libsignal.ProvisioningCipher();
            var gotProvisionEnvelope = false;
            return provisioningCipher.getPublicKey().then(function(pubKey) {
                return new Promise(function(resolve, reject) {
                    var socket = getSocket();
                    socket.onclose = function(e) {
                        console.log('provisioning socket closed', e.code);
                        if (!gotProvisionEnvelope) {
                            reject(new Error('websocket closed'));
                        }
                    };
                    socket.onopen = function(e) {
                        console.log('provisioning socket open');
                    };
                    var wsr = new WebSocketResource(socket, {
                        keepalive: { path: '/v1/keepalive/provisioning' },
                        handleRequest: function(request) {
                            if (request.path === "/v1/address" && request.verb === "PUT") {
                                var proto = textsecure.protobuf.ProvisioningUuid.decode(request.body);
                                setProvisioningUrl([
                                    'tsdevice:/?uuid=', proto.uuid, '&pub_key=',
                                    encodeURIComponent(btoa(getString(pubKey)))
                                ].join(''));
                                request.respond(200, 'OK');
                            } else if (request.path === "/v1/message" && request.verb === "PUT") {
                                var envelope = textsecure.protobuf.ProvisionEnvelope.decode(request.body, 'binary');
                                request.respond(200, 'OK');
                                gotProvisionEnvelope = true;
                                wsr.close();
                                resolve(provisioningCipher.decrypt(envelope).then(function(provisionMessage) {
                                    return queueTask(function() {
                                        return confirmNumber(provisionMessage.number).then(function(deviceName) {
                                            if (typeof deviceName !== 'string' || deviceName.length === 0) {
                                                throw new Error('Invalid device name');
                                            }
                                            return createAccount(
                                                provisionMessage.number,
                                                provisionMessage.provisioningCode,
                                                provisionMessage.identityKeyPair,
                                                provisionMessage.profileKey,
                                                deviceName,
                                                provisionMessage.userAgent,
                                                provisionMessage.readReceipts
                                            )
                                            .then(clearSessionsAndPreKeys)
                                            .then(generateKeys)
                                            .then(function(keys) {
                                                return registerKeys(keys).then(function() {
                                                    return confirmKeys(keys);
                                                });
                                            })
                                            .then(registrationDone);
                                        });
                                    });
                                }));
                            } else {
                                console.log('Unknown websocket message', request.path);
                            }
                        }
                    });
                });
            });
        },
        refreshPreKeys: function() {
            var generateKeys = this.generateKeys.bind(this, 100);
            var registerKeys = this.server.registerKeys.bind(this.server);

            return this.queueTask(function() {
                return this.server.getMyKeys().then(function(preKeyCount) {
                    console.log('prekey count ' + preKeyCount);
                    if (preKeyCount < 10) {
                        return generateKeys().then(registerKeys);
                    }
                });
            }.bind(this));
        },
        rotateSignedPreKey: function() {
            return this.queueTask(function() {
                var signedKeyId = textsecure.storage.get('signedKeyId', 1);
                if (typeof signedKeyId != 'number') {
                    throw new Error('Invalid signedKeyId');
                }

                var store = textsecure.storage.protocol;
                var server = this.server;
                var cleanSignedPreKeys = this.cleanSignedPreKeys;

                // TODO: harden this against missing identity key? Otherwise, we get
                //   retries every five seconds.
                return store.getIdentityKeyPair().then(function(identityKey) {
                    return libsignal.KeyHelper.generateSignedPreKey(identityKey, signedKeyId);
                }, function(error) {
                    console.log('Failed to get identity key. Canceling key rotation.');
                }).then(function(res) {
                    if (!res) {
                        return;
                    }
                    console.log('Saving new signed prekey', res.keyId);
                    return Promise.all([
                        textsecure.storage.put('signedKeyId', signedKeyId + 1),
                        store.storeSignedPreKey(res.keyId, res.keyPair),
                        server.setSignedPreKey({
                            keyId     : res.keyId,
                            publicKey : res.keyPair.pubKey,
                            signature : res.signature
                        }),
                    ]).then(function() {
                        var confirmed = true;
                        console.log('Confirming new signed prekey', res.keyId);
                        return Promise.all([
                            textsecure.storage.remove('signedKeyRotationRejected'),
                            store.storeSignedPreKey(res.keyId, res.keyPair, confirmed),
                        ]);
                    }).then(function() {
                        return cleanSignedPreKeys();
                    });
                }).catch(function(e) {
                    console.log(
                        'rotateSignedPrekey error:',
                        e && e.stack ? e.stack : e
                    );

                    if (e instanceof Error && e.name == 'HTTPError' && e.code >= 400 && e.code <= 599) {
                        var rejections = 1 + textsecure.storage.get('signedKeyRotationRejected', 0);
                        textsecure.storage.put('signedKeyRotationRejected', rejections);
                        console.log('Signed key rotation rejected count:', rejections);
                    } else {
                        throw e;
                    }
                });
            }.bind(this));
        },
        queueTask: function(task) {
            var taskWithTimeout = textsecure.createTaskWithTimeout(task);
            return this.pending = this.pending.then(taskWithTimeout, taskWithTimeout);
        },
        cleanSignedPreKeys: function() {
            var MINIMUM_KEYS = 3;
            var store = textsecure.storage.protocol;
            return store.loadSignedPreKeys().then(function(allKeys) {
                allKeys.sort(function(a, b) {
                    return (a.created_at || 0) - (b.created_at || 0);
                });
                allKeys.reverse(); // we want the most recent first
                var confirmed = allKeys.filter(function(key) {
                    return key.confirmed;
                });
                var unconfirmed = allKeys.filter(function(key) {
                    return !key.confirmed;
                });

                var recent = allKeys[0] ? allKeys[0].keyId : 'none';
                var recentConfirmed = confirmed[0] ? confirmed[0].keyId : 'none';
                console.log('Most recent signed key: ' + recent);
                console.log('Most recent confirmed signed key: ' + recentConfirmed);
                console.log(
                    'Total signed key count:',
                    allKeys.length,
                    '-',
                    confirmed.length,
                    'confirmed'
                );

                var confirmedCount = confirmed.length;

                // Keep MINIMUM_KEYS confirmed keys, then drop if older than a week
                confirmed = confirmed.forEach(function(key, index) {
                    if (index < MINIMUM_KEYS) {
                        return;
                    }
                    var created_at = key.created_at || 0;
                    var age = Date.now() - created_at;
                    if (age > ARCHIVE_AGE) {
                        console.log(
                            'Removing confirmed signed prekey:',
                            key.keyId,
                            'with timestamp:',
                            created_at
                        );
                        store.removeSignedPreKey(key.keyId);
                        confirmedCount--;
                    }
                });

                var stillNeeded = MINIMUM_KEYS - confirmedCount;

                // If we still don't have enough total keys, we keep as many unconfirmed
                // keys as necessary. If not necessary, and over a week old, we drop.
                unconfirmed.forEach(function(key, index) {
                    if (index < stillNeeded) {
                        return;
                    }

                    var created_at = key.created_at || 0;
                    var age = Date.now() - created_at;
                    if (age > ARCHIVE_AGE) {
                        console.log(
                            'Removing unconfirmed signed prekey:',
                            key.keyId,
                            'with timestamp:',
                            created_at
                        );
                        store.removeSignedPreKey(key.keyId);
                    }
                });
            });
        },
        createAccount: function(number, verificationCode, identityKeyPair,
                           profileKey, deviceName, userAgent, readReceipts) {
            var signalingKey = libsignal.crypto.getRandomBytes(32 + 20);
            var password = btoa(getString(libsignal.crypto.getRandomBytes(16)));
            password = password.substring(0, password.length - 2);
            var registrationId = libsignal.KeyHelper.generateRegistrationId();

            var previousNumber = getNumber(textsecure.storage.get('number_id'));

            return this.server.confirmCode(
                number, verificationCode, password, signalingKey, registrationId, deviceName
            ).then(function(response) {
                if (previousNumber && previousNumber !== number) {
                    console.log('New number is different from old number; deleting all previous data');

                    return textsecure.storage.protocol.removeAllData().then(function() {
                        console.log('Successfully deleted previous data');
                        return response;
                    }, function(error) {
                        console.log(
                            'Something went wrong deleting data from previous number',
                            error && error.stack ? error.stack : error
                        );

                        return response;
                    });
                }

                return response;
            }).then(function(response) {
                textsecure.storage.remove('identityKey');
                textsecure.storage.remove('signaling_key');
                textsecure.storage.remove('password');
                textsecure.storage.remove('registrationId');
                textsecure.storage.remove('number_id');
                textsecure.storage.remove('device_name');
                textsecure.storage.remove('regionCode');
                textsecure.storage.remove('userAgent');
                textsecure.storage.remove('profileKey');
                textsecure.storage.remove('read-receipts-setting');

                // update our own identity key, which may have changed
                // if we're relinking after a reinstall on the master device
                textsecure.storage.protocol.saveIdentityWithAttributes(number, {
                    id                  : number,
                    publicKey           : identityKeyPair.pubKey,
                    firstUse            : true,
                    timestamp           : Date.now(),
                    verified            : textsecure.storage.protocol.VerifiedStatus.VERIFIED,
                    nonblockingApproval : true
                });

                textsecure.storage.put('identityKey', identityKeyPair);
                textsecure.storage.put('signaling_key', signalingKey);
                textsecure.storage.put('password', password);
                textsecure.storage.put('registrationId', registrationId);
                if (profileKey) {
                    textsecure.storage.put('profileKey', profileKey);
                }
                if (userAgent) {
                    textsecure.storage.put('userAgent', userAgent);
                }
                if (readReceipts) {
                    textsecure.storage.put('read-receipt-setting', true);
                } else {
                    textsecure.storage.put('read-receipt-setting', false);
                }

                textsecure.storage.user.setNumberAndDeviceId(number, response.deviceId || 1, deviceName);
                textsecure.storage.put('regionCode', libphonenumber.util.getRegionCodeForNumber(number));
                this.server.username = textsecure.storage.get('number_id');
            }.bind(this));
        },
        clearSessionsAndPreKeys: function() {
            var store = textsecure.storage.protocol;

            console.log('clearing all sessions, prekeys, and signed prekeys');
            return Promise.all([
                store.clearPreKeyStore(),
                store.clearSignedPreKeysStore(),
                store.clearSessionStore(),
            ]);
        },
        // Takes the same object returned by generateKeys
        confirmKeys: function(keys) {
            var store = textsecure.storage.protocol;
            var key = keys.signedPreKey;
            var confirmed = true;

            console.log('confirmKeys: confirming key', key.keyId);
            return store.storeSignedPreKey(key.keyId, key.keyPair, confirmed);
        },
        generateKeys: function (count, progressCallback) {
            if (typeof progressCallback !== 'function') {
                progressCallback = undefined;
            }
            var startId = textsecure.storage.get('maxPreKeyId', 1);
            var signedKeyId = textsecure.storage.get('signedKeyId', 1);

            if (typeof startId != 'number') {
                throw new Error('Invalid maxPreKeyId');
            }
            if (typeof signedKeyId != 'number') {
                throw new Error('Invalid signedKeyId');
            }

            var store = textsecure.storage.protocol;
            return store.getIdentityKeyPair().then(function(identityKey) {
                var result = { preKeys: [], identityKey: identityKey.pubKey };
                var promises = [];

                for (var keyId = startId; keyId < startId+count; ++keyId) {
                    promises.push(
                        libsignal.KeyHelper.generatePreKey(keyId).then(function(res) {
                            store.storePreKey(res.keyId, res.keyPair);
                            result.preKeys.push({
                                keyId     : res.keyId,
                                publicKey : res.keyPair.pubKey
                            });
                            if (progressCallback) { progressCallback(); }
                        })
                    );
                }

                promises.push(
                    libsignal.KeyHelper.generateSignedPreKey(identityKey, signedKeyId).then(function(res) {
                        store.storeSignedPreKey(res.keyId, res.keyPair);
                        result.signedPreKey = {
                            keyId     : res.keyId,
                            publicKey : res.keyPair.pubKey,
                            signature : res.signature,
                            // server.registerKeys doesn't use keyPair, confirmKeys does
                            keyPair   : res.keyPair,
                        };
                    })
                );

                textsecure.storage.put('maxPreKeyId', startId + count);
                textsecure.storage.put('signedKeyId', signedKeyId + 1);
                return Promise.all(promises).then(function() {
                    // This is primarily for the signed prekey summary it logs out
                    return this.cleanSignedPreKeys().then(function() {
                        return result;
                    });
                }.bind(this));
            }.bind(this));
        },
        registrationDone: function() {
            console.log('registration done');
            this.dispatchEvent(new Event('registration'));
        }
    });
    textsecure.AccountManager = AccountManager;

}());