hydrogen-web/src/matrix/Session.js

525 lines
19 KiB
JavaScript
Raw Normal View History

2020-08-05 22:08:55 +05:30
/*
Copyright 2020 Bruno Windels <bruno@windels.cloud>
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.
*/
import {Room} from "./room/Room.js";
2019-02-27 01:19:45 +05:30
import { ObservableMap } from "../observable/index.js";
import {User} from "./User.js";
import {DeviceMessageHandler} from "./DeviceMessageHandler.js";
2020-09-03 21:21:11 +05:30
import {Account as E2EEAccount} from "./e2ee/Account.js";
import {Decryption as OlmDecryption} from "./e2ee/olm/Decryption.js";
2020-09-03 19:02:08 +05:30
import {Encryption as OlmEncryption} from "./e2ee/olm/Encryption.js";
import {Decryption as MegOlmDecryption} from "./e2ee/megolm/Decryption.js";
import {SessionBackup} from "./e2ee/megolm/SessionBackup.js";
2020-09-03 21:20:28 +05:30
import {Encryption as MegOlmEncryption} from "./e2ee/megolm/Encryption.js";
2020-09-03 21:21:00 +05:30
import {MEGOLM_ALGORITHM} from "./e2ee/common.js";
2020-09-03 19:06:17 +05:30
import {RoomEncryption} from "./e2ee/RoomEncryption.js";
2020-08-31 17:43:21 +05:30
import {DeviceTracker} from "./e2ee/DeviceTracker.js";
import {LockMap} from "../utils/LockMap.js";
import {groupBy} from "../utils/groupBy.js";
import {
keyFromCredential as ssssKeyFromCredential,
readKey as ssssReadKey,
writeKey as ssssWriteKey,
2020-09-17 21:27:12 +05:30
} from "./ssss/index.js";
import {SecretStorage} from "./ssss/SecretStorage.js";
2020-09-17 21:30:00 +05:30
import {ObservableValue} from "../observable/ObservableValue.js";
const PICKLE_KEY = "DEFAULT_KEY";
2019-02-11 01:55:29 +05:30
export class Session {
// sessionInfo contains deviceId, userId and homeServer
constructor({storage, hsApi, sessionInfo, olm, olmWorker, platform, mediaRepository}) {
this._platform = platform;
2019-05-12 23:56:46 +05:30
this._storage = storage;
this._hsApi = hsApi;
this._mediaRepository = mediaRepository;
this._syncInfo = null;
this._sessionInfo = sessionInfo;
2019-05-12 23:56:46 +05:30
this._rooms = new ObservableMap();
2019-02-24 23:55:06 +05:30
this._roomUpdateCallback = (room, params) => this._rooms.update(room.id, params);
this._user = new User(sessionInfo.userId);
2020-09-02 18:29:17 +05:30
this._deviceMessageHandler = new DeviceMessageHandler({storage});
2020-08-27 16:54:55 +05:30
this._olm = olm;
this._olmUtil = null;
this._e2eeAccount = null;
this._deviceTracker = null;
2020-09-03 19:02:08 +05:30
this._olmEncryption = null;
2020-09-04 19:01:27 +05:30
this._megolmEncryption = null;
this._megolmDecryption = null;
this._getSyncToken = () => this.syncToken;
2020-09-11 14:13:17 +05:30
this._olmWorker = olmWorker;
this._sessionBackup = null;
this._hasSecretStorageKey = new ObservableValue(null);
2020-09-04 19:01:27 +05:30
if (olm) {
this._olmUtil = new olm.Utility();
this._deviceTracker = new DeviceTracker({
storage,
getSyncToken: this._getSyncToken,
olmUtil: this._olmUtil,
2020-09-03 18:58:03 +05:30
ownUserId: sessionInfo.userId,
ownDeviceId: sessionInfo.deviceId,
});
}
2020-09-03 19:06:17 +05:30
this._createRoomEncryption = this._createRoomEncryption.bind(this);
2020-09-17 21:30:00 +05:30
this.needsSessionBackup = new ObservableValue(false);
}
2020-10-16 21:36:20 +05:30
get fingerprintKey() {
return this._e2eeAccount?.identityKeys.ed25519;
}
get hasSecretStorageKey() {
return this._hasSecretStorageKey;
}
2020-10-16 21:36:20 +05:30
get deviceId() {
return this._sessionInfo.deviceId;
}
get userId() {
return this._sessionInfo.userId;
}
// called once this._e2eeAccount is assigned
_setupEncryption() {
// TODO: this should all go in a wrapper in e2ee/ that is bootstrapped by passing in the account
// and can create RoomEncryption objects and handle encrypted to_device messages and device list changes.
const senderKeyLock = new LockMap();
const olmDecryption = new OlmDecryption({
account: this._e2eeAccount,
pickleKey: PICKLE_KEY,
2020-09-03 21:21:11 +05:30
olm: this._olm,
storage: this._storage,
now: this._platform.clock.now,
ownUserId: this._user.id,
senderKeyLock
});
2020-09-03 19:02:08 +05:30
this._olmEncryption = new OlmEncryption({
account: this._e2eeAccount,
pickleKey: PICKLE_KEY,
2020-09-03 21:21:11 +05:30
olm: this._olm,
storage: this._storage,
now: this._platform.clock.now,
2020-09-03 19:02:08 +05:30
ownUserId: this._user.id,
olmUtil: this._olmUtil,
senderKeyLock
});
2020-09-03 21:20:28 +05:30
this._megolmEncryption = new MegOlmEncryption({
account: this._e2eeAccount,
pickleKey: PICKLE_KEY,
olm: this._olm,
storage: this._storage,
now: this._platform.clock.now,
2020-09-03 21:20:28 +05:30
ownDeviceId: this._sessionInfo.deviceId,
2020-09-04 19:01:27 +05:30
});
this._megolmDecryption = new MegOlmDecryption({
pickleKey: PICKLE_KEY,
olm: this._olm,
2020-09-11 14:13:17 +05:30
olmWorker: this._olmWorker,
2020-09-04 19:01:27 +05:30
});
this._deviceMessageHandler.enableEncryption({olmDecryption, megolmDecryption: this._megolmDecryption});
}
2020-09-03 21:20:28 +05:30
_createRoomEncryption(room, encryptionParams) {
2020-09-03 19:06:17 +05:30
// TODO: this will actually happen when users start using the e2ee version for the first time
// this should never happen because either a session was already synced once
// and thus an e2ee account was created as well and _setupEncryption is called from load
// OR
// this is a new session and loading it will load zero rooms, thus not calling this method.
// in this case _setupEncryption is called from beforeFirstSync, right after load,
// so any incoming synced rooms won't be there yet
if (!this._olmEncryption) {
throw new Error("creating room encryption before encryption got globally enabled");
}
2020-09-03 21:21:00 +05:30
// only support megolm
if (encryptionParams.algorithm !== MEGOLM_ALGORITHM) {
return null;
}
2020-09-03 19:06:17 +05:30
return new RoomEncryption({
room,
deviceTracker: this._deviceTracker,
olmEncryption: this._olmEncryption,
2020-09-03 21:20:28 +05:30
megolmEncryption: this._megolmEncryption,
2020-09-04 19:01:27 +05:30
megolmDecryption: this._megolmDecryption,
storage: this._storage,
sessionBackup: this._sessionBackup,
encryptionParams,
2020-09-17 21:30:00 +05:30
notifyMissingMegolmSession: () => {
if (!this._sessionBackup) {
this.needsSessionBackup.set(true)
}
},
clock: this._platform.clock
2020-09-03 19:06:17 +05:30
});
}
/**
* Enable secret storage by providing the secret storage credential.
* This will also see if there is a megolm session backup and try to enable that if so.
*
* @param {string} type either "passphrase" or "recoverykey"
* @param {string} credential either the passphrase or the recovery key, depending on the type
* @return {Promise} resolves or rejects after having tried to enable secret storage
*/
async enableSecretStorage(type, credential) {
if (!this._olm) {
throw new Error("olm required");
}
if (this._sessionBackup) {
return false;
}
2021-02-11 21:59:48 +05:30
const key = await ssssKeyFromCredential(type, credential, this._storage, this._platform, this._olm);
2020-09-17 21:27:12 +05:30
// and create session backup, which needs to read from accountData
const readTxn = await this._storage.readTxn([
2020-09-17 21:27:12 +05:30
this._storage.storeNames.accountData,
]);
await this._createSessionBackup(key, readTxn);
2020-09-17 21:27:12 +05:30
// only after having read a secret, write the key
// as we only find out if it was good if the MAC verification succeeds
const writeTxn = await this._storage.readWriteTxn([
this._storage.storeNames.session,
]);
try {
ssssWriteKey(key, writeTxn);
} catch (err) {
writeTxn.abort();
throw err;
}
await writeTxn.complete();
this._hasSecretStorageKey.set(true);
}
async _createSessionBackup(ssssKey, txn) {
2021-02-11 21:59:48 +05:30
const secretStorage = new SecretStorage({key: ssssKey, platform: this._platform});
this._sessionBackup = await SessionBackup.fromSecretStorage({
platform: this._platform,
olm: this._olm, secretStorage,
hsApi: this._hsApi,
txn
});
if (this._sessionBackup) {
for (const room of this._rooms.values()) {
if (room.isEncrypted) {
room.enableSessionBackup(this._sessionBackup);
}
}
}
2020-09-17 21:30:00 +05:30
this.needsSessionBackup.set(false);
}
2020-10-19 21:59:13 +05:30
get sessionBackup() {
return this._sessionBackup;
}
/** @internal */
2021-02-23 23:52:25 +05:30
async createIdentity(log) {
if (this._olm) {
if (!this._e2eeAccount) {
2020-09-11 14:13:17 +05:30
this._e2eeAccount = await E2EEAccount.create({
hsApi: this._hsApi,
olm: this._olm,
pickleKey: PICKLE_KEY,
userId: this._sessionInfo.userId,
deviceId: this._sessionInfo.deviceId,
olmWorker: this._olmWorker,
storage: this._storage,
});
2021-02-23 23:52:25 +05:30
log.set("keys", this._e2eeAccount.identityKeys);
this._setupEncryption();
}
2021-02-23 23:52:25 +05:30
await this._e2eeAccount.generateOTKsIfNeeded(this._storage, log);
await log.wrap("uploadKeys", log => this._e2eeAccount.uploadKeys(this._storage, log));
}
2019-05-12 23:56:46 +05:30
}
2018-12-21 19:05:24 +05:30
/** @internal */
2021-02-23 23:52:25 +05:30
async load(log) {
const txn = await this._storage.readTxn([
2019-05-12 23:56:46 +05:30
this._storage.storeNames.session,
this._storage.storeNames.roomSummary,
this._storage.storeNames.roomMembers,
2019-05-12 23:56:46 +05:30
this._storage.storeNames.timelineEvents,
2019-05-20 00:19:46 +05:30
this._storage.storeNames.timelineFragments,
this._storage.storeNames.pendingEvents,
2019-05-12 23:56:46 +05:30
]);
// restore session object
this._syncInfo = await txn.session.get("sync");
// restore e2ee account, if any
if (this._olm) {
this._e2eeAccount = await E2EEAccount.load({
hsApi: this._hsApi,
olm: this._olm,
pickleKey: PICKLE_KEY,
userId: this._sessionInfo.userId,
deviceId: this._sessionInfo.deviceId,
2020-09-11 14:13:17 +05:30
olmWorker: this._olmWorker,
txn
});
if (this._e2eeAccount) {
2021-02-23 23:52:25 +05:30
log.set("keys", this._e2eeAccount.identityKeys);
this._setupEncryption();
}
}
const pendingEventsByRoomId = await this._getPendingEventsByRoom(txn);
2019-05-12 23:56:46 +05:30
// load rooms
const rooms = await txn.roomSummary.getAll();
await Promise.all(rooms.map(summary => {
const room = this.createRoom(summary.roomId, pendingEventsByRoomId.get(summary.roomId));
2021-02-23 23:52:25 +05:30
return log.wrap("room", log => room.load(summary, txn, log));
2019-05-12 23:56:46 +05:30
}));
}
2018-12-21 19:05:24 +05:30
2020-09-18 16:38:18 +05:30
dispose() {
2020-09-11 14:13:17 +05:30
this._olmWorker?.dispose();
this._sessionBackup?.dispose();
2020-09-18 16:38:18 +05:30
for (const room of this._rooms.values()) {
room.dispose();
}
2020-04-18 22:46:16 +05:30
}
/**
* @internal called from session container when coming back online and catchup syncs have finished.
* @param {Object} lastVersionResponse a response from /versions, which is polled while offline,
* and useful to store so we can later tell what capabilities
* our homeserver has.
*/
2021-02-23 23:52:25 +05:30
async start(lastVersionResponse, log) {
if (lastVersionResponse) {
// store /versions response
const txn = await this._storage.readWriteTxn([
this._storage.storeNames.session
]);
txn.session.set("serverVersions", lastVersionResponse);
// TODO: what can we do if this throws?
await txn.complete();
}
// enable session backup, this requests the latest backup version
if (!this._sessionBackup) {
const txn = await this._storage.readTxn([
this._storage.storeNames.session,
this._storage.storeNames.accountData,
]);
// try set up session backup if we stored the ssss key
const ssssKey = await ssssReadKey(txn);
if (ssssKey) {
// txn will end here as this does a network request
await this._createSessionBackup(ssssKey, txn);
}
this._hasSecretStorageKey.set(!!ssssKey);
}
// restore unfinished operations, like sending out room keys
const opsTxn = await this._storage.readWriteTxn([
this._storage.storeNames.operations
]);
const operations = await opsTxn.operations.getAll();
const operationsByScope = groupBy(operations, o => o.scope);
2021-02-23 23:50:58 +05:30
for (const room of this._rooms.values()) {
let roomOperationsByType;
const roomOperations = operationsByScope.get(room.id);
if (roomOperations) {
roomOperationsByType = groupBy(roomOperations, r => r.type);
}
2021-02-23 23:52:25 +05:30
room.start(roomOperationsByType, log);
2019-07-27 02:10:39 +05:30
}
}
async _getPendingEventsByRoom(txn) {
const pendingEvents = await txn.pendingEvents.getAll();
return pendingEvents.reduce((groups, pe) => {
const group = groups.get(pe.roomId);
if (group) {
group.push(pe);
} else {
groups.set(pe.roomId, [pe]);
}
return groups;
}, new Map());
}
2019-02-21 04:18:16 +05:30
get rooms() {
return this._rooms;
}
/** @internal */
createRoom(roomId, pendingEvents) {
2019-05-12 23:56:46 +05:30
const room = new Room({
roomId,
getSyncToken: this._getSyncToken,
storage: this._storage,
emitCollectionChange: this._roomUpdateCallback,
hsApi: this._hsApi,
mediaRepository: this._mediaRepository,
pendingEvents,
user: this._user,
createRoomEncryption: this._createRoomEncryption,
platform: this._platform
});
2019-05-12 23:56:46 +05:30
this._rooms.add(roomId, room);
return room;
}
2018-12-21 19:05:24 +05:30
async obtainSyncLock(syncResponse) {
const toDeviceEvents = syncResponse.to_device?.events;
if (Array.isArray(toDeviceEvents) && toDeviceEvents.length) {
return await this._deviceMessageHandler.obtainSyncLock(toDeviceEvents);
}
}
async prepareSync(syncResponse, lock, txn, log) {
const toDeviceEvents = syncResponse.to_device?.events;
if (Array.isArray(toDeviceEvents) && toDeviceEvents.length) {
return await log.wrap("deviceMsgs", log => this._deviceMessageHandler.prepareSync(toDeviceEvents, lock, txn, log));
}
}
/** @internal */
async writeSync(syncResponse, syncFilterId, preparation, txn, log) {
2020-09-24 14:22:56 +05:30
const changes = {
syncInfo: null,
e2eeAccountChanges: null,
};
2020-08-28 17:26:44 +05:30
const syncToken = syncResponse.next_batch;
if (syncToken !== this.syncToken) {
const syncInfo = {token: syncToken, filterId: syncFilterId};
// don't modify `this` because transaction might still fail
txn.session.set("sync", syncInfo);
2020-08-28 17:26:44 +05:30
changes.syncInfo = syncInfo;
}
const deviceOneTimeKeysCount = syncResponse.device_one_time_keys_count;
if (this._e2eeAccount && deviceOneTimeKeysCount) {
2021-02-17 23:15:04 +05:30
changes.e2eeAccountChanges = this._e2eeAccount.writeSync(deviceOneTimeKeysCount, txn, log);
}
const deviceLists = syncResponse.device_lists;
if (this._deviceTracker && Array.isArray(deviceLists?.changed) && deviceLists.changed.length) {
await log.wrap("deviceLists", log => this._deviceTracker.writeDeviceChanges(deviceLists.changed, txn, log));
2020-08-31 17:43:21 +05:30
}
if (preparation) {
await log.wrap("deviceMsgs", log => this._deviceMessageHandler.writeSync(preparation, txn, log));
}
// store account data
const accountData = syncResponse["account_data"];
if (Array.isArray(accountData?.events)) {
for (const event of accountData.events) {
if (typeof event.type === "string") {
txn.accountData.set(event);
}
}
}
2020-08-28 17:26:44 +05:30
return changes;
}
/** @internal */
2020-08-28 17:26:44 +05:30
afterSync({syncInfo, e2eeAccountChanges}) {
if (syncInfo) {
// sync transaction succeeded, modify object state now
this._syncInfo = syncInfo;
2019-05-12 23:56:46 +05:30
}
if (this._e2eeAccount) {
2020-08-28 17:26:44 +05:30
this._e2eeAccount.afterSync(e2eeAccountChanges);
}
2019-05-12 23:56:46 +05:30
}
2019-02-07 05:50:27 +05:30
/** @internal */
2021-02-17 23:15:04 +05:30
async afterSyncCompleted(changes, isCatchupSync, log) {
// we don't start uploading one-time keys until we've caught up with
// to-device messages, to help us avoid throwing away one-time-keys that we
// are about to receive messages for
// (https://github.com/vector-im/riot-web/issues/2782).
if (!isCatchupSync) {
2021-02-23 23:52:25 +05:30
const needsToUploadOTKs = await this._e2eeAccount.generateOTKsIfNeeded(this._storage, log);
if (needsToUploadOTKs) {
await log.wrap("uploadKeys", log => this._e2eeAccount.uploadKeys(this._storage, log));
}
}
}
/** @internal */
2019-05-12 23:56:46 +05:30
get syncToken() {
return this._syncInfo?.token;
2019-05-12 23:56:46 +05:30
}
2019-06-16 14:23:23 +05:30
/** @internal */
2019-10-12 23:54:09 +05:30
get syncFilterId() {
return this._syncInfo?.filterId;
2019-10-12 23:54:09 +05:30
}
get user() {
return this._user;
2019-06-16 14:23:23 +05:30
}
2019-02-21 04:18:16 +05:30
}
export function tests() {
2020-03-15 02:08:37 +05:30
function createStorageMock(session, pendingEvents = []) {
return {
readTxn() {
2020-10-06 15:49:47 +05:30
return {
session: {
get(key) {
return Promise.resolve(session[key]);
}
},
pendingEvents: {
getAll() {
return Promise.resolve(pendingEvents);
}
2020-03-15 02:08:37 +05:30
},
roomSummary: {
getAll() {
return Promise.resolve([]);
}
}
2020-10-06 15:49:47 +05:30
};
2020-03-15 02:08:37 +05:30
},
storeNames: {}
};
}
return {
"session data is not modified until after sync": async (assert) => {
const session = new Session({storage: createStorageMock({
sync: {token: "a", filterId: 5}
2020-03-15 02:08:37 +05:30
}), sessionInfo: {userId: ""}});
await session.load();
let syncSet = false;
const syncTxn = {
session: {
set(key, value) {
if (key === "sync") {
assert.equal(value.token, "b");
assert.equal(value.filterId, 6);
syncSet = true;
}
}
}
};
2021-03-05 21:33:12 +05:30
const newSessionData = await session.writeSync({next_batch: "b"}, 6, null, syncTxn, {});
assert(syncSet);
2020-03-15 02:08:37 +05:30
assert.equal(session.syncToken, "a");
assert.equal(session.syncFilterId, 5);
session.afterSync(newSessionData);
2020-03-15 02:08:37 +05:30
assert.equal(session.syncToken, "b");
assert.equal(session.syncFilterId, 6);
}
}
}