@unwanted/matrix-sdk-mini 34.12.0-2 → 34.12.0-4

package/src/crypto/store/memory-crypto-store.ts

@@ -1,680 +0,0 @@
-/*
-Copyright 2017 - 2021 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.
-*/
-
-import { logger } from "../../logger.ts";
-import { deepCompare, promiseTry, safeSet } from "../../utils.ts";
-import {
-    CryptoStore,
-    IDeviceData,
-    IProblem,
-    ISession,
-    SessionExtended,
-    ISessionInfo,
-    IWithheld,
-    MigrationState,
-    Mode,
-    OutgoingRoomKeyRequest,
-    ParkedSharedHistory,
-    SecretStorePrivateKeys,
-    SESSION_BATCH_SIZE,
-} from "./base.ts";
-import { IRoomKeyRequestBody } from "../index.ts";
-import { IOlmDevice } from "../algorithms/megolm.ts";
-import { IRoomEncryption } from "../RoomList.ts";
-import { InboundGroupSessionData } from "../OlmDevice.ts";
-import { CrossSigningKeyInfo } from "../../crypto-api/index.ts";
-
-function encodeSessionKey(senderCurve25519Key: string, sessionId: string): string {
-    return encodeURIComponent(senderCurve25519Key) + "/" + encodeURIComponent(sessionId);
-}
-
-function decodeSessionKey(key: string): { senderKey: string; sessionId: string } {
-    const keyParts = key.split("/");
-    const senderKey = decodeURIComponent(keyParts[0]);
-    const sessionId = decodeURIComponent(keyParts[1]);
-    return { senderKey, sessionId };
-}
-
-/**
- * Internal module. in-memory storage for e2e.
- */
-
-export class MemoryCryptoStore implements CryptoStore {
-    private migrationState: MigrationState = MigrationState.NOT_STARTED;
-    private outgoingRoomKeyRequests: OutgoingRoomKeyRequest[] = [];
-    private account: string | null = null;
-    private crossSigningKeys: Record<string, CrossSigningKeyInfo> | null = null;
-    private privateKeys: Partial<SecretStorePrivateKeys> = {};
-
-    private sessions: { [deviceKey: string]: { [sessionId: string]: ISessionInfo } } = {};
-    private sessionProblems: { [deviceKey: string]: IProblem[] } = {};
-    private notifiedErrorDevices: { [userId: string]: { [deviceId: string]: boolean } } = {};
-    private inboundGroupSessions: { [sessionKey: string]: InboundGroupSessionData } = {};
-    private inboundGroupSessionsWithheld: Record<string, IWithheld> = {};
-    // Opaque device data object
-    private deviceData: IDeviceData | null = null;
-    private rooms: { [roomId: string]: IRoomEncryption } = {};
-    private sessionsNeedingBackup: { [sessionKey: string]: boolean } = {};
-    private sharedHistoryInboundGroupSessions: { [roomId: string]: [senderKey: string, sessionId: string][] } = {};
-    private parkedSharedHistory = new Map<string, ParkedSharedHistory[]>(); // keyed by room ID
-
-    /**
-     * Returns true if this CryptoStore has ever been initialised (ie, it might contain data).
-     *
-     * Implementation of {@link CryptoStore.containsData}.
-     *
-     * @internal
-     */
-    public async containsData(): Promise<boolean> {
-        // If it contains anything, it should contain an account.
-        return this.account !== null;
-    }
-
-    /**
-     * Ensure the database exists and is up-to-date.
-     *
-     * This must be called before the store can be used.
-     *
-     * @returns resolves to the store.
-     */
-    public async startup(): Promise<CryptoStore> {
-        // No startup work to do for the memory store.
-        return this;
-    }
-
-    /**
-     * Delete all data from this store.
-     *
-     * @returns Promise which resolves when the store has been cleared.
-     */
-    public deleteAllData(): Promise<void> {
-        return Promise.resolve();
-    }
-
-    /**
-     * Get data on how much of the libolm to Rust Crypto migration has been done.
-     *
-     * Implementation of {@link CryptoStore.getMigrationState}.
-     *
-     * @internal
-     */
-    public async getMigrationState(): Promise<MigrationState> {
-        return this.migrationState;
-    }
-
-    /**
-     * Set data on how much of the libolm to Rust Crypto migration has been done.
-     *
-     * Implementation of {@link CryptoStore.setMigrationState}.
-     *
-     * @internal
-     */
-    public async setMigrationState(migrationState: MigrationState): Promise<void> {
-        this.migrationState = migrationState;
-    }
-
-    /**
-     * Look for an existing outgoing room key request, and if none is found,
-     * add a new one
-     *
-     *
-     * @returns resolves to
-     *    {@link OutgoingRoomKeyRequest}: either the
-     *    same instance as passed in, or the existing one.
-     */
-    public getOrAddOutgoingRoomKeyRequest(request: OutgoingRoomKeyRequest): Promise<OutgoingRoomKeyRequest> {
-        const requestBody = request.requestBody;
-
-        return promiseTry(() => {
-            // first see if we already have an entry for this request.
-            const existing = this._getOutgoingRoomKeyRequest(requestBody);
-
-            if (existing) {
-                // this entry matches the request - return it.
-                logger.log(
-                    `already have key request outstanding for ` +
-                        `${requestBody.room_id} / ${requestBody.session_id}: ` +
-                        `not sending another`,
-                );
-                return existing;
-            }
-
-            // we got to the end of the list without finding a match
-            // - add the new request.
-            logger.log(`enqueueing key request for ${requestBody.room_id} / ` + requestBody.session_id);
-            this.outgoingRoomKeyRequests.push(request);
-            return request;
-        });
-    }
-
-    /**
-     * Look for an existing room key request
-     *
-     * @param requestBody - existing request to look for
-     *
-     * @returns resolves to the matching
-     *    {@link OutgoingRoomKeyRequest}, or null if
-     *    not found
-     */
-    public getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<OutgoingRoomKeyRequest | null> {
-        return Promise.resolve(this._getOutgoingRoomKeyRequest(requestBody));
-    }
-
-    /**
-     * Looks for existing room key request, and returns the result synchronously.
-     *
-     * @internal
-     *
-     * @param requestBody - existing request to look for
-     *
-     * @returns
-     *    the matching request, or null if not found
-     */
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    private _getOutgoingRoomKeyRequest(requestBody: IRoomKeyRequestBody): OutgoingRoomKeyRequest | null {
-        for (const existing of this.outgoingRoomKeyRequests) {
-            if (deepCompare(existing.requestBody, requestBody)) {
-                return existing;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Look for room key requests by state
-     *
-     * @param wantedStates - list of acceptable states
-     *
-     * @returns resolves to the a
-     *    {@link OutgoingRoomKeyRequest}, or null if
-     *    there are no pending requests in those states
-     */
-    public getOutgoingRoomKeyRequestByState(wantedStates: number[]): Promise<OutgoingRoomKeyRequest | null> {
-        for (const req of this.outgoingRoomKeyRequests) {
-            for (const state of wantedStates) {
-                if (req.state === state) {
-                    return Promise.resolve(req);
-                }
-            }
-        }
-        return Promise.resolve(null);
-    }
-
-    /**
-     *
-     * @returns All OutgoingRoomKeyRequests in state
-     */
-    public getAllOutgoingRoomKeyRequestsByState(wantedState: number): Promise<OutgoingRoomKeyRequest[]> {
-        return Promise.resolve(this.outgoingRoomKeyRequests.filter((r) => r.state == wantedState));
-    }
-
-    public getOutgoingRoomKeyRequestsByTarget(
-        userId: string,
-        deviceId: string,
-        wantedStates: number[],
-    ): Promise<OutgoingRoomKeyRequest[]> {
-        const results: OutgoingRoomKeyRequest[] = [];
-
-        for (const req of this.outgoingRoomKeyRequests) {
-            for (const state of wantedStates) {
-                if (
-                    req.state === state &&
-                    req.recipients.some((recipient) => recipient.userId === userId && recipient.deviceId === deviceId)
-                ) {
-                    results.push(req);
-                }
-            }
-        }
-        return Promise.resolve(results);
-    }
-
-    /**
-     * Look for an existing room key request by id and state, and update it if
-     * found
-     *
-     * @param requestId -      ID of request to update
-     * @param expectedState -  state we expect to find the request in
-     * @param updates -        name/value map of updates to apply
-     *
-     * @returns resolves to
-     *    {@link OutgoingRoomKeyRequest}
-     *    updated request, or null if no matching row was found
-     */
-    public updateOutgoingRoomKeyRequest(
-        requestId: string,
-        expectedState: number,
-        updates: Partial<OutgoingRoomKeyRequest>,
-    ): Promise<OutgoingRoomKeyRequest | null> {
-        for (const req of this.outgoingRoomKeyRequests) {
-            if (req.requestId !== requestId) {
-                continue;
-            }
-
-            if (req.state !== expectedState) {
-                logger.warn(
-                    `Cannot update room key request from ${expectedState} ` +
-                        `as it was already updated to ${req.state}`,
-                );
-                return Promise.resolve(null);
-            }
-            Object.assign(req, updates);
-            return Promise.resolve(req);
-        }
-
-        return Promise.resolve(null);
-    }
-
-    /**
-     * Look for an existing room key request by id and state, and delete it if
-     * found
-     *
-     * @param requestId -      ID of request to update
-     * @param expectedState -  state we expect to find the request in
-     *
-     * @returns resolves once the operation is completed
-     */
-    public deleteOutgoingRoomKeyRequest(
-        requestId: string,
-        expectedState: number,
-    ): Promise<OutgoingRoomKeyRequest | null> {
-        for (let i = 0; i < this.outgoingRoomKeyRequests.length; i++) {
-            const req = this.outgoingRoomKeyRequests[i];
-
-            if (req.requestId !== requestId) {
-                continue;
-            }
-
-            if (req.state != expectedState) {
-                logger.warn(`Cannot delete room key request in state ${req.state} ` + `(expected ${expectedState})`);
-                return Promise.resolve(null);
-            }
-
-            this.outgoingRoomKeyRequests.splice(i, 1);
-            return Promise.resolve(req);
-        }
-
-        return Promise.resolve(null);
-    }
-
-    // Olm Account
-
-    public getAccount(txn: unknown, func: (accountPickle: string | null) => void): void {
-        func(this.account);
-    }
-
-    public storeAccount(txn: unknown, accountPickle: string): void {
-        this.account = accountPickle;
-    }
-
-    public getCrossSigningKeys(txn: unknown, func: (keys: Record<string, CrossSigningKeyInfo> | null) => void): void {
-        func(this.crossSigningKeys);
-    }
-
-    public getSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
-        txn: unknown,
-        func: (key: SecretStorePrivateKeys[K] | null) => void,
-        type: K,
-    ): void {
-        const result = this.privateKeys[type] as SecretStorePrivateKeys[K] | undefined;
-        func(result || null);
-    }
-
-    public storeCrossSigningKeys(txn: unknown, keys: Record<string, CrossSigningKeyInfo>): void {
-        this.crossSigningKeys = keys;
-    }
-
-    public storeSecretStorePrivateKey<K extends keyof SecretStorePrivateKeys>(
-        txn: unknown,
-        type: K,
-        key: SecretStorePrivateKeys[K],
-    ): void {
-        this.privateKeys[type] = key;
-    }
-
-    // Olm Sessions
-
-    public countEndToEndSessions(txn: unknown, func: (count: number) => void): void {
-        let count = 0;
-        for (const deviceSessions of Object.values(this.sessions)) {
-            count += Object.keys(deviceSessions).length;
-        }
-        func(count);
-    }
-
-    public getEndToEndSession(
-        deviceKey: string,
-        sessionId: string,
-        txn: unknown,
-        func: (session: ISessionInfo) => void,
-    ): void {
-        const deviceSessions = this.sessions[deviceKey] || {};
-        func(deviceSessions[sessionId] || null);
-    }
-
-    public getEndToEndSessions(
-        deviceKey: string,
-        txn: unknown,
-        func: (sessions: { [sessionId: string]: ISessionInfo }) => void,
-    ): void {
-        func(this.sessions[deviceKey] || {});
-    }
-
-    public getAllEndToEndSessions(txn: unknown, func: (session: ISessionInfo) => void): void {
-        Object.entries(this.sessions).forEach(([deviceKey, deviceSessions]) => {
-            Object.entries(deviceSessions).forEach(([sessionId, session]) => {
-                func({
-                    ...session,
-                    deviceKey,
-                    sessionId,
-                });
-            });
-        });
-    }
-
-    public storeEndToEndSession(deviceKey: string, sessionId: string, sessionInfo: ISessionInfo, txn: unknown): void {
-        let deviceSessions = this.sessions[deviceKey];
-        if (deviceSessions === undefined) {
-            deviceSessions = {};
-            this.sessions[deviceKey] = deviceSessions;
-        }
-        safeSet(deviceSessions, sessionId, sessionInfo);
-    }
-
-    public async storeEndToEndSessionProblem(deviceKey: string, type: string, fixed: boolean): Promise<void> {
-        const problems = (this.sessionProblems[deviceKey] = this.sessionProblems[deviceKey] || []);
-        problems.push({ type, fixed, time: Date.now() });
-        problems.sort((a, b) => {
-            return a.time - b.time;
-        });
-    }
-
-    public async getEndToEndSessionProblem(deviceKey: string, timestamp: number): Promise<IProblem | null> {
-        const problems = this.sessionProblems[deviceKey] || [];
-        if (!problems.length) {
-            return null;
-        }
-        const lastProblem = problems[problems.length - 1];
-        for (const problem of problems) {
-            if (problem.time > timestamp) {
-                return Object.assign({}, problem, { fixed: lastProblem.fixed });
-            }
-        }
-        if (lastProblem.fixed) {
-            return null;
-        } else {
-            return lastProblem;
-        }
-    }
-
-    public async filterOutNotifiedErrorDevices(devices: IOlmDevice[]): Promise<IOlmDevice[]> {
-        const notifiedErrorDevices = this.notifiedErrorDevices;
-        const ret: IOlmDevice[] = [];
-
-        for (const device of devices) {
-            const { userId, deviceInfo } = device;
-            if (userId in notifiedErrorDevices) {
-                if (!(deviceInfo.deviceId in notifiedErrorDevices[userId])) {
-                    ret.push(device);
-                    safeSet(notifiedErrorDevices[userId], deviceInfo.deviceId, true);
-                }
-            } else {
-                ret.push(device);
-                safeSet(notifiedErrorDevices, userId, { [deviceInfo.deviceId]: true });
-            }
-        }
-
-        return ret;
-    }
-
-    /**
-     * Fetch a batch of Olm sessions from the database.
-     *
-     * Implementation of {@link CryptoStore.getEndToEndSessionsBatch}.
-     *
-     * @internal
-     */
-    public async getEndToEndSessionsBatch(): Promise<null | ISessionInfo[]> {
-        const result: ISessionInfo[] = [];
-        for (const deviceSessions of Object.values(this.sessions)) {
-            for (const session of Object.values(deviceSessions)) {
-                result.push(session);
-                if (result.length >= SESSION_BATCH_SIZE) {
-                    return result;
-                }
-            }
-        }
-
-        if (result.length === 0) {
-            // No sessions left.
-            return null;
-        }
-
-        // There are fewer sessions than the batch size; return the final batch of sessions.
-        return result;
-    }
-
-    /**
-     * Delete a batch of Olm sessions from the database.
-     *
-     * Implementation of {@link CryptoStore.deleteEndToEndSessionsBatch}.
-     *
-     * @internal
-     */
-    public async deleteEndToEndSessionsBatch(sessions: { deviceKey: string; sessionId: string }[]): Promise<void> {
-        for (const { deviceKey, sessionId } of sessions) {
-            const deviceSessions = this.sessions[deviceKey] || {};
-            delete deviceSessions[sessionId];
-            if (Object.keys(deviceSessions).length === 0) {
-                // No more sessions for this device.
-                delete this.sessions[deviceKey];
-            }
-        }
-    }
-
-    // Inbound Group Sessions
-
-    public getEndToEndInboundGroupSession(
-        senderCurve25519Key: string,
-        sessionId: string,
-        txn: unknown,
-        func: (groupSession: InboundGroupSessionData | null, groupSessionWithheld: IWithheld | null) => void,
-    ): void {
-        const k = encodeSessionKey(senderCurve25519Key, sessionId);
-        func(this.inboundGroupSessions[k] || null, this.inboundGroupSessionsWithheld[k] || null);
-    }
-
-    public getAllEndToEndInboundGroupSessions(txn: unknown, func: (session: ISession | null) => void): void {
-        for (const key of Object.keys(this.inboundGroupSessions)) {
-            func({
-                ...decodeSessionKey(key),
-                sessionData: this.inboundGroupSessions[key],
-            });
-        }
-        func(null);
-    }
-
-    public addEndToEndInboundGroupSession(
-        senderCurve25519Key: string,
-        sessionId: string,
-        sessionData: InboundGroupSessionData,
-        txn: unknown,
-    ): void {
-        const k = encodeSessionKey(senderCurve25519Key, sessionId);
-        if (this.inboundGroupSessions[k] === undefined) {
-            this.inboundGroupSessions[k] = sessionData;
-        }
-    }
-
-    public storeEndToEndInboundGroupSession(
-        senderCurve25519Key: string,
-        sessionId: string,
-        sessionData: InboundGroupSessionData,
-        txn: unknown,
-    ): void {
-        const k = encodeSessionKey(senderCurve25519Key, sessionId);
-        this.inboundGroupSessions[k] = sessionData;
-    }
-
-    public storeEndToEndInboundGroupSessionWithheld(
-        senderCurve25519Key: string,
-        sessionId: string,
-        sessionData: IWithheld,
-        txn: unknown,
-    ): void {
-        const k = encodeSessionKey(senderCurve25519Key, sessionId);
-        this.inboundGroupSessionsWithheld[k] = sessionData;
-    }
-
-    /**
-     * Count the number of Megolm sessions in the database.
-     *
-     * Implementation of {@link CryptoStore.countEndToEndInboundGroupSessions}.
-     *
-     * @internal
-     */
-    public async countEndToEndInboundGroupSessions(): Promise<number> {
-        return Object.keys(this.inboundGroupSessions).length;
-    }
-
-    /**
-     * Fetch a batch of Megolm sessions from the database.
-     *
-     * Implementation of {@link CryptoStore.getEndToEndInboundGroupSessionsBatch}.
-     *
-     * @internal
-     */
-    public async getEndToEndInboundGroupSessionsBatch(): Promise<null | SessionExtended[]> {
-        const result: SessionExtended[] = [];
-        for (const [key, session] of Object.entries(this.inboundGroupSessions)) {
-            result.push({
-                ...decodeSessionKey(key),
-                sessionData: session,
-                needsBackup: key in this.sessionsNeedingBackup,
-            });
-            if (result.length >= SESSION_BATCH_SIZE) {
-                return result;
-            }
-        }
-
-        if (result.length === 0) {
-            // No sessions left.
-            return null;
-        }
-
-        // There are fewer sessions than the batch size; return the final batch of sessions.
-        return result;
-    }
-
-    /**
-     * Delete a batch of Megolm sessions from the database.
-     *
-     * Implementation of {@link CryptoStore.deleteEndToEndInboundGroupSessionsBatch}.
-     *
-     * @internal
-     */
-    public async deleteEndToEndInboundGroupSessionsBatch(
-        sessions: { senderKey: string; sessionId: string }[],
-    ): Promise<void> {
-        for (const { senderKey, sessionId } of sessions) {
-            const k = encodeSessionKey(senderKey, sessionId);
-            delete this.inboundGroupSessions[k];
-        }
-    }
-
-    // Device Data
-
-    public getEndToEndDeviceData(txn: unknown, func: (deviceData: IDeviceData | null) => void): void {
-        func(this.deviceData);
-    }
-
-    public storeEndToEndDeviceData(deviceData: IDeviceData, txn: unknown): void {
-        this.deviceData = deviceData;
-    }
-
-    // E2E rooms
-
-    public storeEndToEndRoom(roomId: string, roomInfo: IRoomEncryption, txn: unknown): void {
-        this.rooms[roomId] = roomInfo;
-    }
-
-    public getEndToEndRooms(txn: unknown, func: (rooms: Record<string, IRoomEncryption>) => void): void {
-        func(this.rooms);
-    }
-
-    public getSessionsNeedingBackup(limit: number): Promise<ISession[]> {
-        const sessions: ISession[] = [];
-        for (const session in this.sessionsNeedingBackup) {
-            if (this.inboundGroupSessions[session]) {
-                sessions.push({
-                    ...decodeSessionKey(session),
-                    sessionData: this.inboundGroupSessions[session],
-                });
-                if (limit && session.length >= limit) {
-                    break;
-                }
-            }
-        }
-        return Promise.resolve(sessions);
-    }
-
-    public countSessionsNeedingBackup(): Promise<number> {
-        return Promise.resolve(Object.keys(this.sessionsNeedingBackup).length);
-    }
-
-    public unmarkSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        for (const session of sessions) {
-            const sessionKey = encodeSessionKey(session.senderKey, session.sessionId);
-            delete this.sessionsNeedingBackup[sessionKey];
-        }
-        return Promise.resolve();
-    }
-
-    public markSessionsNeedingBackup(sessions: ISession[]): Promise<void> {
-        for (const session of sessions) {
-            const sessionKey = encodeSessionKey(session.senderKey, session.sessionId);
-            this.sessionsNeedingBackup[sessionKey] = true;
-        }
-        return Promise.resolve();
-    }
-
-    public addSharedHistoryInboundGroupSession(roomId: string, senderKey: string, sessionId: string): void {
-        const sessions = this.sharedHistoryInboundGroupSessions[roomId] || [];
-        sessions.push([senderKey, sessionId]);
-        this.sharedHistoryInboundGroupSessions[roomId] = sessions;
-    }
-
-    public getSharedHistoryInboundGroupSessions(roomId: string): Promise<[senderKey: string, sessionId: string][]> {
-        return Promise.resolve(this.sharedHistoryInboundGroupSessions[roomId] || []);
-    }
-
-    public addParkedSharedHistory(roomId: string, parkedData: ParkedSharedHistory): void {
-        const parked = this.parkedSharedHistory.get(roomId) ?? [];
-        parked.push(parkedData);
-        this.parkedSharedHistory.set(roomId, parked);
-    }
-
-    public takeParkedSharedHistory(roomId: string): Promise<ParkedSharedHistory[]> {
-        const parked = this.parkedSharedHistory.get(roomId) ?? [];
-        this.parkedSharedHistory.delete(roomId);
-        return Promise.resolve(parked);
-    }
-
-    // Session key backups
-
-    public doTxn<T>(mode: Mode, stores: Iterable<string>, func: (txn?: unknown) => T): Promise<T> {
-        return Promise.resolve(func(null));
-    }
-}