matrix-react-sdk
Version:
SDK for matrix.org using React
251 lines (194 loc) • 28.2 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SetupEncryptionStore = exports.PHASE_FINISHED = exports.PHASE_CONFIRM_SKIP = exports.PHASE_DONE = exports.PHASE_BUSY = exports.PHASE_INTRO = exports.PHASE_LOADING = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _events = _interopRequireDefault(require("events"));
var _MatrixClientPeg = require("../MatrixClientPeg");
var _SecurityManager = require("../SecurityManager");
var _VerificationRequest = require("matrix-js-sdk/src/crypto/verification/request/VerificationRequest");
/*
Copyright 2020 The Matrix.org Foundation C.I.C.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
const PHASE_LOADING = 0;
exports.PHASE_LOADING = PHASE_LOADING;
const PHASE_INTRO = 1;
exports.PHASE_INTRO = PHASE_INTRO;
const PHASE_BUSY = 2;
exports.PHASE_BUSY = PHASE_BUSY;
const PHASE_DONE = 3; //final done stage, but still showing UX
exports.PHASE_DONE = PHASE_DONE;
const PHASE_CONFIRM_SKIP = 4;
exports.PHASE_CONFIRM_SKIP = PHASE_CONFIRM_SKIP;
const PHASE_FINISHED = 5; //UX can be closed
exports.PHASE_FINISHED = PHASE_FINISHED;
class SetupEncryptionStore extends _events.default {
constructor(...args) {
super(...args);
(0, _defineProperty2.default)(this, "_onUserTrustStatusChanged", userId => {
if (userId !== _MatrixClientPeg.MatrixClientPeg.get().getUserId()) return;
const publicKeysTrusted = _MatrixClientPeg.MatrixClientPeg.get().getCrossSigningId();
if (publicKeysTrusted) {
this.phase = PHASE_DONE;
this.emit("update");
}
});
(0, _defineProperty2.default)(this, "onVerificationRequest", request => {
this._setActiveVerificationRequest(request);
});
(0, _defineProperty2.default)(this, "onVerificationRequestChange", () => {
if (this.verificationRequest.cancelled) {
this.verificationRequest.off("change", this.onVerificationRequestChange);
this.verificationRequest = null;
this.emit("update");
} else if (this.verificationRequest.phase === _VerificationRequest.PHASE_DONE) {
this.verificationRequest.off("change", this.onVerificationRequestChange);
this.verificationRequest = null; // At this point, the verification has finished, we just need to wait for
// cross signing to be ready to use, so wait for the user trust status to
// change (or change to DONE if it's already ready).
const publicKeysTrusted = _MatrixClientPeg.MatrixClientPeg.get().getCrossSigningId();
this.phase = publicKeysTrusted ? PHASE_DONE : PHASE_BUSY;
this.emit("update");
}
});
}
static sharedInstance() {
if (!global.mx_SetupEncryptionStore) global.mx_SetupEncryptionStore = new SetupEncryptionStore();
return global.mx_SetupEncryptionStore;
}
start() {
if (this._started) {
return;
}
this._started = true;
this.phase = PHASE_LOADING;
this.verificationRequest = null;
this.backupInfo = null; // ID of the key that the secrets we want are encrypted with
this.keyId = null; // Descriptor of the key that the secrets we want are encrypted with
this.keyInfo = null;
const cli = _MatrixClientPeg.MatrixClientPeg.get();
cli.on("crypto.verification.request", this.onVerificationRequest);
cli.on('userTrustStatusChanged', this._onUserTrustStatusChanged);
const requestsInProgress = cli.getVerificationRequestsToDeviceInProgress(cli.getUserId());
if (requestsInProgress.length) {
// If there are multiple, we take the most recent. Equally if the user sends another request from
// another device after this screen has been shown, we'll switch to the new one, so this
// generally doesn't support multiple requests.
this._setActiveVerificationRequest(requestsInProgress[requestsInProgress.length - 1]);
}
this.fetchKeyInfo();
}
stop() {
if (!this._started) {
return;
}
this._started = false;
if (this.verificationRequest) {
this.verificationRequest.off("change", this.onVerificationRequestChange);
}
if (_MatrixClientPeg.MatrixClientPeg.get()) {
_MatrixClientPeg.MatrixClientPeg.get().removeListener("crypto.verification.request", this.onVerificationRequest);
_MatrixClientPeg.MatrixClientPeg.get().removeListener('userTrustStatusChanged', this._onUserTrustStatusChanged);
}
}
async fetchKeyInfo() {
const cli = _MatrixClientPeg.MatrixClientPeg.get();
const keys = await cli.isSecretStored('m.cross_signing.master', false);
if (keys === null || Object.keys(keys).length === 0) {
this.keyId = null;
this.keyInfo = null;
} else {
// If the secret is stored under more than one key, we just pick an arbitrary one
this.keyId = Object.keys(keys)[0];
this.keyInfo = keys[this.keyId];
} // do we have any other devices which are E2EE which we can verify against?
const dehydratedDevice = await cli.getDehydratedDevice();
this.hasDevicesToVerifyAgainst = cli.getStoredDevicesForUser(cli.getUserId()).some(device => device.getIdentityKey() && (!dehydratedDevice || device.deviceId != dehydratedDevice.device_id));
if (!this.hasDevicesToVerifyAgainst && !this.keyInfo) {
// skip before we can even render anything.
this.phase = PHASE_FINISHED;
} else {
this.phase = PHASE_INTRO;
}
this.emit("update");
}
async usePassPhrase() {
this.phase = PHASE_BUSY;
this.emit("update");
const cli = _MatrixClientPeg.MatrixClientPeg.get();
try {
const backupInfo = await cli.getKeyBackupVersion();
this.backupInfo = backupInfo;
this.emit("update"); // The control flow is fairly twisted here...
// For the purposes of completing security, we only wait on getting
// as far as the trust check and then show a green shield.
// We also begin the key backup restore as well, which we're
// awaiting inside `accessSecretStorage` only so that it keeps your
// passphase cached for that work. This dialog itself will only wait
// on the first trust check, and the key backup restore will happen
// in the background.
await new Promise((resolve, reject) => {
(0, _SecurityManager.accessSecretStorage)(async () => {
await cli.checkOwnCrossSigningTrust();
resolve();
if (backupInfo) {
// A complete restore can take many minutes for large
// accounts / slow servers, so we allow the dialog
// to advance before this.
await cli.restoreKeyBackupWithSecretStorage(backupInfo);
}
}).catch(reject);
});
if (cli.getCrossSigningId()) {
this.phase = PHASE_DONE;
this.emit("update");
}
} catch (e) {
if (!(e instanceof _SecurityManager.AccessCancelledError)) {
console.log(e);
} // this will throw if the user hits cancel, so ignore
this.phase = PHASE_INTRO;
this.emit("update");
}
}
skip() {
this.phase = PHASE_CONFIRM_SKIP;
this.emit("update");
}
skipConfirm() {
this.phase = PHASE_FINISHED;
this.emit("update");
}
returnAfterSkip() {
this.phase = PHASE_INTRO;
this.emit("update");
}
done() {
this.phase = PHASE_FINISHED;
this.emit("update"); // async - ask other clients for keys, if necessary
_MatrixClientPeg.MatrixClientPeg.get()._crypto.cancelAndResendAllOutgoingKeyRequests();
}
async _setActiveVerificationRequest(request) {
if (request.otherUserId !== _MatrixClientPeg.MatrixClientPeg.get().getUserId()) return;
if (this.verificationRequest) {
this.verificationRequest.off("change", this.onVerificationRequestChange);
}
this.verificationRequest = request;
await request.accept();
request.on("change", this.onVerificationRequestChange);
this.emit("update");
}
}
exports.SetupEncryptionStore = SetupEncryptionStore;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/stores/SetupEncryptionStore.js"],"names":["PHASE_LOADING","PHASE_INTRO","PHASE_BUSY","PHASE_DONE","PHASE_CONFIRM_SKIP","PHASE_FINISHED","SetupEncryptionStore","EventEmitter","userId","MatrixClientPeg","get","getUserId","publicKeysTrusted","getCrossSigningId","phase","emit","request","_setActiveVerificationRequest","verificationRequest","cancelled","off","onVerificationRequestChange","VERIF_PHASE_DONE","sharedInstance","global","mx_SetupEncryptionStore","start","_started","backupInfo","keyId","keyInfo","cli","on","onVerificationRequest","_onUserTrustStatusChanged","requestsInProgress","getVerificationRequestsToDeviceInProgress","length","fetchKeyInfo","stop","removeListener","keys","isSecretStored","Object","dehydratedDevice","getDehydratedDevice","hasDevicesToVerifyAgainst","getStoredDevicesForUser","some","device","getIdentityKey","deviceId","device_id","usePassPhrase","getKeyBackupVersion","Promise","resolve","reject","checkOwnCrossSigningTrust","restoreKeyBackupWithSecretStorage","catch","e","AccessCancelledError","console","log","skip","skipConfirm","returnAfterSkip","done","_crypto","cancelAndResendAllOutgoingKeyRequests","otherUserId","accept"],"mappings":"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","sourcesContent":["/*\nCopyright 2020 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport EventEmitter from 'events';\nimport { MatrixClientPeg } from '../MatrixClientPeg';\nimport { accessSecretStorage, AccessCancelledError } from '../SecurityManager';\nimport { PHASE_DONE as VERIF_PHASE_DONE } from \"matrix-js-sdk/src/crypto/verification/request/VerificationRequest\";\n\nexport const PHASE_LOADING = 0;\nexport const PHASE_INTRO = 1;\nexport const PHASE_BUSY = 2;\nexport const PHASE_DONE = 3;    //final done stage, but still showing UX\nexport const PHASE_CONFIRM_SKIP = 4;\nexport const PHASE_FINISHED = 5; //UX can be closed\n\nexport class SetupEncryptionStore extends EventEmitter {\n    static sharedInstance() {\n        if (!global.mx_SetupEncryptionStore) global.mx_SetupEncryptionStore = new SetupEncryptionStore();\n        return global.mx_SetupEncryptionStore;\n    }\n\n    start() {\n        if (this._started) {\n            return;\n        }\n        this._started = true;\n        this.phase = PHASE_LOADING;\n        this.verificationRequest = null;\n        this.backupInfo = null;\n\n        // ID of the key that the secrets we want are encrypted with\n        this.keyId = null;\n        // Descriptor of the key that the secrets we want are encrypted with\n        this.keyInfo = null;\n\n        const cli = MatrixClientPeg.get();\n        cli.on(\"crypto.verification.request\", this.onVerificationRequest);\n        cli.on('userTrustStatusChanged', this._onUserTrustStatusChanged);\n\n        const requestsInProgress = cli.getVerificationRequestsToDeviceInProgress(cli.getUserId());\n        if (requestsInProgress.length) {\n            // If there are multiple, we take the most recent. Equally if the user sends another request from\n            // another device after this screen has been shown, we'll switch to the new one, so this\n            // generally doesn't support multiple requests.\n            this._setActiveVerificationRequest(requestsInProgress[requestsInProgress.length - 1]);\n        }\n\n        this.fetchKeyInfo();\n    }\n\n    stop() {\n        if (!this._started) {\n            return;\n        }\n        this._started = false;\n        if (this.verificationRequest) {\n            this.verificationRequest.off(\"change\", this.onVerificationRequestChange);\n        }\n        if (MatrixClientPeg.get()) {\n            MatrixClientPeg.get().removeListener(\"crypto.verification.request\", this.onVerificationRequest);\n            MatrixClientPeg.get().removeListener('userTrustStatusChanged', this._onUserTrustStatusChanged);\n        }\n    }\n\n    async fetchKeyInfo() {\n        const cli = MatrixClientPeg.get();\n        const keys = await cli.isSecretStored('m.cross_signing.master', false);\n        if (keys === null || Object.keys(keys).length === 0) {\n            this.keyId = null;\n            this.keyInfo = null;\n        } else {\n            // If the secret is stored under more than one key, we just pick an arbitrary one\n            this.keyId = Object.keys(keys)[0];\n            this.keyInfo = keys[this.keyId];\n        }\n\n        // do we have any other devices which are E2EE which we can verify against?\n        const dehydratedDevice = await cli.getDehydratedDevice();\n        this.hasDevicesToVerifyAgainst = cli.getStoredDevicesForUser(cli.getUserId()).some(\n            device =>\n                device.getIdentityKey() &&\n                (!dehydratedDevice || (device.deviceId != dehydratedDevice.device_id)),\n        );\n\n        if (!this.hasDevicesToVerifyAgainst && !this.keyInfo) {\n            // skip before we can even render anything.\n            this.phase = PHASE_FINISHED;\n        } else {\n            this.phase = PHASE_INTRO;\n        }\n        this.emit(\"update\");\n    }\n\n    async usePassPhrase() {\n        this.phase = PHASE_BUSY;\n        this.emit(\"update\");\n        const cli = MatrixClientPeg.get();\n        try {\n            const backupInfo = await cli.getKeyBackupVersion();\n            this.backupInfo = backupInfo;\n            this.emit(\"update\");\n            // The control flow is fairly twisted here...\n            // For the purposes of completing security, we only wait on getting\n            // as far as the trust check and then show a green shield.\n            // We also begin the key backup restore as well, which we're\n            // awaiting inside `accessSecretStorage` only so that it keeps your\n            // passphase cached for that work. This dialog itself will only wait\n            // on the first trust check, and the key backup restore will happen\n            // in the background.\n            await new Promise((resolve, reject) => {\n                accessSecretStorage(async () => {\n                    await cli.checkOwnCrossSigningTrust();\n                    resolve();\n                    if (backupInfo) {\n                        // A complete restore can take many minutes for large\n                        // accounts / slow servers, so we allow the dialog\n                        // to advance before this.\n                        await cli.restoreKeyBackupWithSecretStorage(backupInfo);\n                    }\n                }).catch(reject);\n            });\n\n            if (cli.getCrossSigningId()) {\n                this.phase = PHASE_DONE;\n                this.emit(\"update\");\n            }\n        } catch (e) {\n            if (!(e instanceof AccessCancelledError)) {\n                console.log(e);\n            }\n            // this will throw if the user hits cancel, so ignore\n            this.phase = PHASE_INTRO;\n            this.emit(\"update\");\n        }\n    }\n\n    _onUserTrustStatusChanged = (userId) => {\n        if (userId !== MatrixClientPeg.get().getUserId()) return;\n        const publicKeysTrusted = MatrixClientPeg.get().getCrossSigningId();\n        if (publicKeysTrusted) {\n            this.phase = PHASE_DONE;\n            this.emit(\"update\");\n        }\n    }\n\n    onVerificationRequest = (request) => {\n        this._setActiveVerificationRequest(request);\n    }\n\n    onVerificationRequestChange = () => {\n        if (this.verificationRequest.cancelled) {\n            this.verificationRequest.off(\"change\", this.onVerificationRequestChange);\n            this.verificationRequest = null;\n            this.emit(\"update\");\n        } else if (this.verificationRequest.phase === VERIF_PHASE_DONE) {\n            this.verificationRequest.off(\"change\", this.onVerificationRequestChange);\n            this.verificationRequest = null;\n            // At this point, the verification has finished, we just need to wait for\n            // cross signing to be ready to use, so wait for the user trust status to\n            // change (or change to DONE if it's already ready).\n            const publicKeysTrusted = MatrixClientPeg.get().getCrossSigningId();\n            this.phase = publicKeysTrusted ? PHASE_DONE : PHASE_BUSY;\n            this.emit(\"update\");\n        }\n    }\n\n    skip() {\n        this.phase = PHASE_CONFIRM_SKIP;\n        this.emit(\"update\");\n    }\n\n    skipConfirm() {\n        this.phase = PHASE_FINISHED;\n        this.emit(\"update\");\n    }\n\n    returnAfterSkip() {\n        this.phase = PHASE_INTRO;\n        this.emit(\"update\");\n    }\n\n    done() {\n        this.phase = PHASE_FINISHED;\n        this.emit(\"update\");\n        // async - ask other clients for keys, if necessary\n        MatrixClientPeg.get()._crypto.cancelAndResendAllOutgoingKeyRequests();\n    }\n\n    async _setActiveVerificationRequest(request) {\n        if (request.otherUserId !== MatrixClientPeg.get().getUserId()) return;\n\n        if (this.verificationRequest) {\n            this.verificationRequest.off(\"change\", this.onVerificationRequestChange);\n        }\n        this.verificationRequest = request;\n        await request.accept();\n        request.on(\"change\", this.onVerificationRequestChange);\n        this.emit(\"update\");\n    }\n}\n"]}