@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/rust-crypto/PerSessionKeyBackupDownloader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerSessionKeyBackupDownloader.js","names":["CryptoEvent","ClientPrefix","MatrixError","Method","encodeUri","sleep","KEY_BACKUP_BACKOFF","KeyDownloadErrorCode","KeyDownloadError","Error","constructor","code","concat","name","KeyDownloadRateLimitError","retryMillis","PerSessionKeyBackupDownloader","logger","olmMachine","http","backupManager","_defineProperty","Map","hasConfigurationProblem","configuration","getOrCreateBackupConfiguration","then","downloadKeysLoop","getChild","on","KeyBackupStatus","onBackupStatusChanged","KeyBackupFailed","KeyBackupDecryptionKeyCached","isKeyBackupDownloadConfigured","getServerBackupInfo","_this","_asyncToGenerator","onDecryptionKeyMissingError","roomId","megolmSessionId","isAlreadyInQueue","trace","wasRequestedRecently","queuedRequests","push","stop","stopped","off","some","info","markAsNotFoundInBackup","now","Date","sessionLastCheckAttemptedTime","set","size","Array","from","filter","sid","ts","Math","max","lastCheck","get","getBackupDecryptionKey","_this2","getBackupKeys","_unused","requestRoomKeyFromBackup","version","sessionId","_this3","path","$roomId","$sessionId","authedRequest","Get","undefined","prefix","V3","_this4","downloadLoopRunning","length","request","result","queryKeyBackup","decryptAndImport","e","error","shift","err","MISSING_DECRYPTION_KEY","NETWORK_ERROR","STOPPED","targetRoomId","targetSessionId","_this5","debug","res","backupVersion","errCode","data","errcode","isRateLimitError","_waitTime","waitTime","_e$getRetryAfterMs","getRetryAfterMs","warn","sessionInfo","_this6","sessionsToImport","keys","decryptor","decryptSessions","k","room_id","importBackedUpRoomKeys","_this7","currentBackupVersionCheck","internalCheckFromServer","_this8","_currentServerVersion","_currentServerVersion2","_currentServerVersion4","currentServerVersion","algorithm","_currentServerVersion3","activeVersion","getActiveBackupVersion","backupKeys","decryptionKey","authData","auth_data","public_key","megolmV1PublicKey","publicKeyBase64","backupDecryptor","createBackupDecryptor"],"sources":["../../src/rust-crypto/PerSessionKeyBackupDownloader.ts"],"sourcesContent":["/*\nCopyright 2023 - 2024 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 * as RustSdkCryptoJs from \"@matrix-org/matrix-sdk-crypto-wasm\";\nimport { OlmMachine } from \"@matrix-org/matrix-sdk-crypto-wasm\";\n\nimport { Curve25519AuthData, KeyBackupInfo, KeyBackupSession } from \"../crypto-api/keybackup.ts\";\nimport { CryptoEvent } from \"../crypto-api/index.ts\";\nimport { Logger } from \"../logger.ts\";\nimport { ClientPrefix, IHttpOpts, MatrixError, MatrixHttpApi, Method } from \"../http-api/index.ts\";\nimport { RustBackupManager } from \"./backup.ts\";\nimport { encodeUri, sleep } from \"../utils.ts\";\nimport { BackupDecryptor } from \"../common-crypto/CryptoBackend.ts\";\n\n// The minimum time to wait between two retries in case of errors. To avoid hammering the server.\nconst KEY_BACKUP_BACKOFF = 5000; // ms\n\n/**\n * Enumerates the different kind of errors that can occurs when downloading and importing a key from backup.\n */\nenum KeyDownloadErrorCode {\n    /** The requested key is not in the backup. */\n    MISSING_DECRYPTION_KEY = \"MISSING_DECRYPTION_KEY\",\n    /** A network error occurred while trying to download the key from backup. */\n    NETWORK_ERROR = \"NETWORK_ERROR\",\n    /** The loop has been stopped. */\n    STOPPED = \"STOPPED\",\n}\n\nclass KeyDownloadError extends Error {\n    public constructor(public readonly code: KeyDownloadErrorCode) {\n        super(`Failed to get key from backup: ${code}`);\n        this.name = \"KeyDownloadError\";\n    }\n}\n\nclass KeyDownloadRateLimitError extends Error {\n    public constructor(public readonly retryMillis: number) {\n        super(`Failed to get key from backup: rate limited`);\n        this.name = \"KeyDownloadRateLimitError\";\n    }\n}\n\n/** Details of a megolm session whose key we are trying to fetch. */\ntype SessionInfo = { roomId: string; megolmSessionId: string };\n\n/** Holds the current backup decryptor and version that should be used.\n *\n * This is intended to be used as an immutable object (a new instance should be created if the configuration changes),\n * and some of the logic relies on that, so the properties are marked as `readonly`.\n */\ntype Configuration = {\n    readonly backupVersion: string;\n    readonly decryptor: BackupDecryptor;\n};\n\n/**\n * Used when an 'unable to decrypt' error occurs. It attempts to download the key from the backup.\n *\n * The current backup API lacks pagination, which can lead to lengthy key retrieval times for large histories (several 10s of minutes).\n * To mitigate this, keys are downloaded on demand as decryption errors occurs.\n * While this approach may result in numerous requests, it improves user experience by reducing wait times for message decryption.\n *\n * The PerSessionKeyBackupDownloader is resistant to backup configuration changes: it will automatically resume querying when\n * the backup is configured correctly.\n */\nexport class PerSessionKeyBackupDownloader {\n    private stopped = false;\n\n    /**\n     * The version and decryption key to use with current backup if all set up correctly.\n     *\n     * Will not be set unless `hasConfigurationProblem` is `false`.\n     */\n    private configuration: Configuration | null = null;\n\n    /** We remember when a session was requested and not found in backup to avoid query again too soon.\n     * Map of session_id to timestamp */\n    private sessionLastCheckAttemptedTime: Map<string, number> = new Map();\n\n    /** The logger to use */\n    private readonly logger: Logger;\n\n    /** Whether the download loop is running. */\n    private downloadLoopRunning = false;\n\n    /** The list of requests that are queued. */\n    private queuedRequests: SessionInfo[] = [];\n\n    /** Remembers if we have a configuration problem. */\n    private hasConfigurationProblem = false;\n\n    /** The current server backup version check promise. To avoid doing a server call if one is in flight. */\n    private currentBackupVersionCheck: Promise<Configuration | null> | null = null;\n\n    /**\n     * Creates a new instance of PerSessionKeyBackupDownloader.\n     *\n     * @param backupManager - The backup manager to use.\n     * @param olmMachine - The olm machine to use.\n     * @param http - The http instance to use.\n     * @param logger - The logger to use.\n     */\n    public constructor(\n        logger: Logger,\n        private readonly olmMachine: OlmMachine,\n        private readonly http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,\n        private readonly backupManager: RustBackupManager,\n    ) {\n        this.logger = logger.getChild(\"[PerSessionKeyBackupDownloader]\");\n\n        backupManager.on(CryptoEvent.KeyBackupStatus, this.onBackupStatusChanged);\n        backupManager.on(CryptoEvent.KeyBackupFailed, this.onBackupStatusChanged);\n        backupManager.on(CryptoEvent.KeyBackupDecryptionKeyCached, this.onBackupStatusChanged);\n    }\n\n    /**\n     * Check if key download is successfully configured and active.\n     *\n     * @return `true` if key download is correctly configured and active; otherwise `false`.\n     */\n    public isKeyBackupDownloadConfigured(): boolean {\n        return this.configuration !== null;\n    }\n\n    /**\n     * Return the details of the latest backup on the server, when we last checked.\n     *\n     * This is just a convenience method to expose {@link RustBackupManager.getServerBackupInfo}.\n     */\n    public async getServerBackupInfo(): Promise<KeyBackupInfo | null | undefined> {\n        return await this.backupManager.getServerBackupInfo();\n    }\n\n    /**\n     * Called when a MissingRoomKey or UnknownMessageIndex decryption error is encountered.\n     *\n     * This will try to download the key from the backup if there is a trusted active backup.\n     * In case of success the key will be imported and the onRoomKeysUpdated callback will be called\n     * internally by the rust-sdk and decryption will be retried.\n     *\n     * @param roomId - The room ID of the room where the error occurred.\n     * @param megolmSessionId - The megolm session ID that is missing.\n     */\n    public onDecryptionKeyMissingError(roomId: string, megolmSessionId: string): void {\n        // Several messages encrypted with the same session may be decrypted at the same time,\n        // so we need to be resistant and not query several time the same session.\n        if (this.isAlreadyInQueue(roomId, megolmSessionId)) {\n            // There is already a request queued for this session, no need to queue another one.\n            this.logger.trace(`Not checking key backup for session ${megolmSessionId} as it is already queued`);\n            return;\n        }\n\n        if (this.wasRequestedRecently(megolmSessionId)) {\n            // We already tried to download this session recently and it was not in backup, no need to try again.\n            this.logger.trace(\n                `Not checking key backup for session ${megolmSessionId} as it was already requested recently`,\n            );\n            return;\n        }\n\n        // We always add the request to the queue, even if we have a configuration problem (can't access backup).\n        // This is to make sure that if the configuration problem is resolved, we will try to download the key.\n        // This will happen after an initial sync, at this point the backup will not yet be trusted and the decryption\n        // key will not be available, but it will be just after the verification.\n        // We don't need to persist it because currently on refresh the sdk will retry to decrypt the messages in error.\n        this.queuedRequests.push({ roomId, megolmSessionId });\n\n        // Start the download loop if it's not already running.\n        this.downloadKeysLoop();\n    }\n\n    public stop(): void {\n        this.stopped = true;\n        this.backupManager.off(CryptoEvent.KeyBackupStatus, this.onBackupStatusChanged);\n        this.backupManager.off(CryptoEvent.KeyBackupFailed, this.onBackupStatusChanged);\n        this.backupManager.off(CryptoEvent.KeyBackupDecryptionKeyCached, this.onBackupStatusChanged);\n    }\n\n    /**\n     * Called when the backup status changes (CryptoEvents)\n     * This will trigger a check of the backup configuration.\n     */\n    private onBackupStatusChanged = (): void => {\n        // we want to force check configuration, so we clear the current one.\n        this.hasConfigurationProblem = false;\n        this.configuration = null;\n        this.getOrCreateBackupConfiguration().then((configuration) => {\n            if (configuration) {\n                // restart the download loop if it was stopped\n                this.downloadKeysLoop();\n            }\n        });\n    };\n\n    /** Returns true if the megolm session is already queued for download. */\n    private isAlreadyInQueue(roomId: string, megolmSessionId: string): boolean {\n        return this.queuedRequests.some((info) => {\n            return info.roomId == roomId && info.megolmSessionId == megolmSessionId;\n        });\n    }\n\n    /**\n     * Marks the session as not found in backup, to avoid retrying to soon for a key not in backup\n     *\n     * @param megolmSessionId - The megolm session ID that is missing.\n     */\n    private markAsNotFoundInBackup(megolmSessionId: string): void {\n        const now = Date.now();\n        this.sessionLastCheckAttemptedTime.set(megolmSessionId, now);\n        // if too big make some cleaning to keep under control\n        if (this.sessionLastCheckAttemptedTime.size > 100) {\n            this.sessionLastCheckAttemptedTime = new Map(\n                Array.from(this.sessionLastCheckAttemptedTime).filter((sid, ts) => {\n                    return Math.max(now - ts, 0) < KEY_BACKUP_BACKOFF;\n                }),\n            );\n        }\n    }\n\n    /** Returns true if the session was requested recently. */\n    private wasRequestedRecently(megolmSessionId: string): boolean {\n        const lastCheck = this.sessionLastCheckAttemptedTime.get(megolmSessionId);\n        if (!lastCheck) return false;\n        return Math.max(Date.now() - lastCheck, 0) < KEY_BACKUP_BACKOFF;\n    }\n\n    private async getBackupDecryptionKey(): Promise<RustSdkCryptoJs.BackupKeys | null> {\n        try {\n            return await this.olmMachine.getBackupKeys();\n        } catch {\n            return null;\n        }\n    }\n\n    /**\n     * Requests a key from the server side backup.\n     *\n     * @param version - The backup version to use.\n     * @param roomId - The room ID of the room where the error occurred.\n     * @param sessionId - The megolm session ID that is missing.\n     */\n    private async requestRoomKeyFromBackup(\n        version: string,\n        roomId: string,\n        sessionId: string,\n    ): Promise<KeyBackupSession> {\n        const path = encodeUri(\"/room_keys/keys/$roomId/$sessionId\", {\n            $roomId: roomId,\n            $sessionId: sessionId,\n        });\n\n        return await this.http.authedRequest<KeyBackupSession>(Method.Get, path, { version }, undefined, {\n            prefix: ClientPrefix.V3,\n        });\n    }\n\n    private async downloadKeysLoop(): Promise<void> {\n        if (this.downloadLoopRunning) return;\n\n        // If we have a configuration problem, we don't want to try to download.\n        // If any configuration change is detected, we will retry and restart the loop.\n        if (this.hasConfigurationProblem) return;\n\n        this.downloadLoopRunning = true;\n\n        try {\n            while (this.queuedRequests.length > 0) {\n                // we just peek the first one without removing it, so if a new request for same key comes in while we're\n                // processing this one, it won't queue another request.\n                const request = this.queuedRequests[0];\n                try {\n                    // The backup could have changed between the time we queued the request and now, so we need to check\n                    const configuration = await this.getOrCreateBackupConfiguration();\n                    if (!configuration) {\n                        // Backup is not configured correctly, so stop the loop.\n                        this.downloadLoopRunning = false;\n                        return;\n                    }\n\n                    const result = await this.queryKeyBackup(request.roomId, request.megolmSessionId, configuration);\n\n                    if (this.stopped) {\n                        return;\n                    }\n                    // We got the encrypted key from backup, let's try to decrypt and import it.\n                    try {\n                        await this.decryptAndImport(request, result, configuration);\n                    } catch (e) {\n                        this.logger.error(\n                            `Error while decrypting and importing key backup for session ${request.megolmSessionId}`,\n                            e,\n                        );\n                    }\n                    // now remove the request from the queue as we've processed it.\n                    this.queuedRequests.shift();\n                } catch (err) {\n                    if (err instanceof KeyDownloadError) {\n                        switch (err.code) {\n                            case KeyDownloadErrorCode.MISSING_DECRYPTION_KEY:\n                                this.markAsNotFoundInBackup(request.megolmSessionId);\n                                // continue for next one\n                                this.queuedRequests.shift();\n                                break;\n                            case KeyDownloadErrorCode.NETWORK_ERROR:\n                                // We don't want to hammer if there is a problem, so wait a bit.\n                                await sleep(KEY_BACKUP_BACKOFF);\n                                break;\n                            case KeyDownloadErrorCode.STOPPED:\n                                // If the downloader was stopped, we don't want to retry.\n                                this.downloadLoopRunning = false;\n                                return;\n                        }\n                    } else if (err instanceof KeyDownloadRateLimitError) {\n                        // we want to retry after the backoff time\n                        await sleep(err.retryMillis);\n                    }\n                }\n            }\n        } finally {\n            // all pending request have been processed, we can stop the loop.\n            this.downloadLoopRunning = false;\n        }\n    }\n\n    /**\n     * Query the backup for a key.\n     *\n     * @param targetRoomId - ID of the room that the session is used in.\n     * @param targetSessionId - ID of the session for which to check backup.\n     * @param configuration - The backup configuration to use.\n     */\n    private async queryKeyBackup(\n        targetRoomId: string,\n        targetSessionId: string,\n        configuration: Configuration,\n    ): Promise<KeyBackupSession> {\n        this.logger.debug(`Checking key backup for session ${targetSessionId}`);\n        if (this.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);\n        try {\n            const res = await this.requestRoomKeyFromBackup(configuration.backupVersion, targetRoomId, targetSessionId);\n            this.logger.debug(`Got key from backup for sessionId:${targetSessionId}`);\n            return res;\n        } catch (e) {\n            if (this.stopped) throw new KeyDownloadError(KeyDownloadErrorCode.STOPPED);\n\n            this.logger.info(`No luck requesting key backup for session ${targetSessionId}: ${e}`);\n            if (e instanceof MatrixError) {\n                const errCode = e.data.errcode;\n                if (errCode == \"M_NOT_FOUND\") {\n                    // Unfortunately the spec doesn't give us a way to differentiate between a missing key and a wrong version.\n                    // Synapse will return:\n                    //     - \"error\": \"Unknown backup version\" if the version is wrong.\n                    //     - \"error\": \"No room_keys found\" if the key is missing.\n                    // It's useful to know if the key is missing or if the version is wrong.\n                    // As it's not spec'ed, we fall back on considering the key is not in backup.\n                    // Notice that this request will be lost if instead the backup got out of sync (updated from other session).\n                    throw new KeyDownloadError(KeyDownloadErrorCode.MISSING_DECRYPTION_KEY);\n                }\n                if (e.isRateLimitError()) {\n                    let waitTime: number | undefined;\n                    try {\n                        waitTime = e.getRetryAfterMs() ?? undefined;\n                    } catch (error) {\n                        this.logger.warn(\"Error while retrieving a rate-limit retry delay\", error);\n                    }\n                    if (waitTime && waitTime > 0) {\n                        this.logger.info(`Rate limited by server, waiting ${waitTime}ms`);\n                    }\n                    throw new KeyDownloadRateLimitError(waitTime ?? KEY_BACKUP_BACKOFF);\n                }\n            }\n            throw new KeyDownloadError(KeyDownloadErrorCode.NETWORK_ERROR);\n        }\n    }\n\n    private async decryptAndImport(\n        sessionInfo: SessionInfo,\n        data: KeyBackupSession,\n        configuration: Configuration,\n    ): Promise<void> {\n        const sessionsToImport: Record<string, KeyBackupSession> = { [sessionInfo.megolmSessionId]: data };\n\n        const keys = await configuration!.decryptor.decryptSessions(sessionsToImport);\n        for (const k of keys) {\n            k.room_id = sessionInfo.roomId;\n        }\n        await this.backupManager.importBackedUpRoomKeys(keys, configuration.backupVersion);\n    }\n\n    /**\n     * Gets the current backup configuration or create one if it doesn't exist.\n     *\n     * When a valid configuration is found it is cached and returned for subsequent calls.\n     * Otherwise, if a check is forced or a check has not yet been done, a new check is done.\n     *\n     * @returns The backup configuration to use or null if there is a configuration problem.\n     */\n    private async getOrCreateBackupConfiguration(): Promise<Configuration | null> {\n        if (this.configuration) {\n            return this.configuration;\n        }\n\n        // We already tried to check the configuration and it failed.\n        // We don't want to try again immediately, we will retry if a configuration change is detected.\n        if (this.hasConfigurationProblem) {\n            return null;\n        }\n\n        // This method can be called rapidly by several emitted CryptoEvent, so we need to make sure that we don't\n        // query the server several times.\n        if (this.currentBackupVersionCheck != null) {\n            this.logger.debug(`Already checking server version, use current promise`);\n            return await this.currentBackupVersionCheck;\n        }\n\n        this.currentBackupVersionCheck = this.internalCheckFromServer();\n        try {\n            return await this.currentBackupVersionCheck;\n        } finally {\n            this.currentBackupVersionCheck = null;\n        }\n    }\n\n    private async internalCheckFromServer(): Promise<Configuration | null> {\n        let currentServerVersion = null;\n        try {\n            currentServerVersion = await this.backupManager.getServerBackupInfo();\n        } catch (e) {\n            this.logger.debug(`Backup: error while checking server version: ${e}`);\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n        this.logger.debug(`Got current backup version from server: ${currentServerVersion?.version}`);\n\n        if (currentServerVersion?.algorithm != \"m.megolm_backup.v1.curve25519-aes-sha2\") {\n            this.logger.info(`Unsupported algorithm ${currentServerVersion?.algorithm}`);\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        if (!currentServerVersion?.version) {\n            this.logger.info(`No current key backup`);\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        const activeVersion = await this.backupManager.getActiveBackupVersion();\n        if (activeVersion == null || currentServerVersion.version != activeVersion) {\n            // Either the current backup version on server side is not trusted, or it is out of sync with the active version on the client side.\n            this.logger.info(\n                `The current backup version on the server (${currentServerVersion.version}) is not trusted. Version we are currently backing up to: ${activeVersion}`,\n            );\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        const backupKeys = await this.getBackupDecryptionKey();\n        if (!backupKeys?.decryptionKey) {\n            this.logger.debug(`Not checking key backup for session (no decryption key)`);\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        if (activeVersion != backupKeys.backupVersion) {\n            this.logger.debug(\n                `Version for which we have a decryption key (${backupKeys.backupVersion}) doesn't match the version we are backing up to (${activeVersion})`,\n            );\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        const authData = currentServerVersion.auth_data as Curve25519AuthData;\n        if (authData.public_key != backupKeys.decryptionKey.megolmV1PublicKey.publicKeyBase64) {\n            this.logger.debug(`Key backup on server does not match our decryption key`);\n            this.hasConfigurationProblem = true;\n            return null;\n        }\n\n        const backupDecryptor = this.backupManager.createBackupDecryptor(backupKeys.decryptionKey);\n        this.hasConfigurationProblem = false;\n        this.configuration = {\n            decryptor: backupDecryptor,\n            backupVersion: activeVersion,\n        };\n        return this.configuration;\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/rust-crypto/RoomEncryptor.d.ts

@@ -0,0 +1,98 @@
+import { HistoryVisibility as RustHistoryVisibility, OlmMachine } from "@matrix-org/matrix-sdk-crypto-wasm";
+import { IContent, MatrixEvent } from "../models/event.ts";
+import { Room } from "../models/room.ts";
+import { KeyClaimManager } from "./KeyClaimManager.ts";
+import { RoomMember } from "../models/room-member.ts";
+import { HistoryVisibility } from "../@types/partials.ts";
+import { OutgoingRequestsManager } from "./OutgoingRequestsManager.ts";
+import { DeviceIsolationMode } from "../crypto-api/index.ts";
+/**
+ * RoomEncryptor: responsible for encrypting messages to a given room
+ *
+ * @internal
+ */
+export declare class RoomEncryptor {
+    private readonly olmMachine;
+    private readonly keyClaimManager;
+    private readonly outgoingRequestManager;
+    private readonly room;
+    private encryptionSettings;
+    private readonly prefixedLogger;
+    /** whether the room members have been loaded and tracked for the first time */
+    private lazyLoadedMembersResolved;
+    /**
+     * Ensures that there is only one encryption operation at a time for that room.
+     *
+     * An encryption operation is either a {@link prepareForEncryption} or an {@link encryptEvent} call.
+     */
+    private currentEncryptionPromise;
+    /**
+     * @param olmMachine - The rust-sdk's OlmMachine
+     * @param keyClaimManager - Our KeyClaimManager, which manages the queue of one-time-key claim requests
+     * @param outgoingRequestManager - The OutgoingRequestManager, which manages the queue of outgoing requests.
+     * @param room - The room we want to encrypt for
+     * @param encryptionSettings - body of the m.room.encryption event currently in force in this room
+     */
+    constructor(olmMachine: OlmMachine, keyClaimManager: KeyClaimManager, outgoingRequestManager: OutgoingRequestsManager, room: Room, encryptionSettings: IContent);
+    /**
+     * Handle a new `m.room.encryption` event in this room
+     *
+     * @param config - The content of the encryption event
+     */
+    onCryptoEvent(config: IContent): void;
+    /**
+     * Handle a new `m.room.member` event in this room
+     *
+     * @param member - new membership state
+     */
+    onRoomMembership(member: RoomMember): void;
+    /**
+     * Prepare to encrypt events in this room.
+     *
+     * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices
+     * in the room.
+     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+     * will not send encrypted messages to unverified devices.
+     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+     */
+    prepareForEncryption(globalBlacklistUnverifiedDevices: boolean, deviceIsolationMode: DeviceIsolationMode): Promise<void>;
+    /**
+     * Encrypt an event for this room, or prepare for encryption.
+     *
+     * This will ensure that we have a megolm session for this room, share it with the devices in the room, and
+     * then, if an event is provided, encrypt it using the session.
+     *
+     * @param event - Event to be encrypted, or null if only preparing for encryption (in which case we will pre-share the room key).
+     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+     * will not send encrypted messages to unverified devices.
+     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+     */
+    encryptEvent(event: MatrixEvent | null, globalBlacklistUnverifiedDevices: boolean, deviceIsolationMode: DeviceIsolationMode): Promise<void>;
+    /**
+     * Prepare to encrypt events in this room.
+     *
+     * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices
+     * in the room.
+     *
+     * @param logger - a place to write diagnostics to
+     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+     * will not send encrypted messages to unverified devices.
+     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+     */
+    private ensureEncryptionSession;
+    /**
+     * Discard any existing group session for this room
+     */
+    forceDiscardSession(): Promise<void>;
+    private encryptEventInner;
+}
+/**
+ * Convert a HistoryVisibility to a RustHistoryVisibility
+ * @param visibility - HistoryVisibility enum
+ * @returns a RustHistoryVisibility enum
+ */
+export declare function toRustHistoryVisibility(visibility: HistoryVisibility): RustHistoryVisibility;
+//# sourceMappingURL=RoomEncryptor.d.ts.map

package/lib/rust-crypto/RoomEncryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoomEncryptor.d.ts","sourceRoot":"","sources":["../../src/rust-crypto/RoomEncryptor.ts"],"names":[],"mappings":"AAiBA,OAAO,EAIH,iBAAiB,IAAI,qBAAqB,EAC1C,UAAU,EAIb,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,EAAE,mBAAmB,EAA2B,MAAM,wBAAwB,CAAC;AAEtF;;;;GAIG;AACH,qBAAa,aAAa;IAqBlB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,kBAAkB;IAxB9B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAExC,+EAA+E;IAC/E,OAAO,CAAC,yBAAyB,CAAS;IAE1C;;;;OAIG;IACH,OAAO,CAAC,wBAAwB,CAAoC;IAEpE;;;;;;OAMG;gBAEkB,UAAU,EAAE,UAAU,EACtB,eAAe,EAAE,eAAe,EAChC,sBAAsB,EAAE,uBAAuB,EAC/C,IAAI,EAAE,IAAI,EACnB,kBAAkB,EAAE,QAAQ;IAgBxC;;;;OAIG;IACI,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;IAO5C;;;;OAIG;IACI,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAcjD;;;;;;;;;OASG;IACU,oBAAoB,CAC7B,gCAAgC,EAAE,OAAO,EACzC,mBAAmB,EAAE,mBAAmB,GACzC,OAAO,CAAC,IAAI,CAAC;IAWhB;;;;;;;;;;;OAWG;IACI,YAAY,CACf,KAAK,EAAE,WAAW,GAAG,IAAI,EACzB,gCAAgC,EAAE,OAAO,EACzC,mBAAmB,EAAE,mBAAmB,GACzC,OAAO,CAAC,IAAI,CAAC;IAwBhB;;;;;;;;;;;OAWG;YACW,uBAAuB;IAiHrC;;OAEG;IACU,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;YAOnC,iBAAiB;CAiBlC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,iBAAiB,GAAG,qBAAqB,CAW5F"}

package/lib/rust-crypto/RoomEncryptor.js

@@ -0,0 +1,299 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2023 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 * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
+import { CollectStrategy, EncryptionAlgorithm, EncryptionSettings, HistoryVisibility as RustHistoryVisibility, RoomId, UserId } from "@matrix-org/matrix-sdk-crypto-wasm";
+import { EventType } from "../@types/event.js";
+import { logger, LogSpan } from "../logger.js";
+import { HistoryVisibility } from "../@types/partials.js";
+import { logDuration } from "../utils.js";
+import { KnownMembership } from "../@types/membership.js";
+import { DeviceIsolationModeKind } from "../crypto-api/index.js";
+
+/**
+ * RoomEncryptor: responsible for encrypting messages to a given room
+ *
+ * @internal
+ */
+export class RoomEncryptor {
+  /**
+   * @param olmMachine - The rust-sdk's OlmMachine
+   * @param keyClaimManager - Our KeyClaimManager, which manages the queue of one-time-key claim requests
+   * @param outgoingRequestManager - The OutgoingRequestManager, which manages the queue of outgoing requests.
+   * @param room - The room we want to encrypt for
+   * @param encryptionSettings - body of the m.room.encryption event currently in force in this room
+   */
+  constructor(olmMachine, keyClaimManager, outgoingRequestManager, room, encryptionSettings) {
+    this.olmMachine = olmMachine;
+    this.keyClaimManager = keyClaimManager;
+    this.outgoingRequestManager = outgoingRequestManager;
+    this.room = room;
+    this.encryptionSettings = encryptionSettings;
+    _defineProperty(this, "prefixedLogger", void 0);
+    /** whether the room members have been loaded and tracked for the first time */
+    _defineProperty(this, "lazyLoadedMembersResolved", false);
+    /**
+     * Ensures that there is only one encryption operation at a time for that room.
+     *
+     * An encryption operation is either a {@link prepareForEncryption} or an {@link encryptEvent} call.
+     */
+    _defineProperty(this, "currentEncryptionPromise", Promise.resolve());
+    this.prefixedLogger = logger.getChild("[".concat(room.roomId, " encryption]"));
+
+    // start tracking devices for any users already known to be in this room.
+    // Do not load members here, would defeat lazy loading.
+    var members = room.getJoinedMembers();
+
+    // At this point just mark the known members as tracked, it might not be the full list of members
+    // because of lazy loading. This is fine, because we will get a member list update when sending a message for
+    // the first time, see `RoomEncryptor#ensureEncryptionSession`
+    this.olmMachine.updateTrackedUsers(members.map(u => new RustSdkCryptoJs.UserId(u.userId))).catch(e => this.prefixedLogger.error("Error initializing tracked users", e));
+  }
+
+  /**
+   * Handle a new `m.room.encryption` event in this room
+   *
+   * @param config - The content of the encryption event
+   */
+  onCryptoEvent(config) {
+    if (JSON.stringify(this.encryptionSettings) != JSON.stringify(config)) {
+      // This should currently be unreachable, since the Rust SDK will reject any attempts to change config.
+      throw new Error("Cannot reconfigure an active RoomEncryptor");
+    }
+  }
+
+  /**
+   * Handle a new `m.room.member` event in this room
+   *
+   * @param member - new membership state
+   */
+  onRoomMembership(member) {
+    if (member.membership == KnownMembership.Join || member.membership == KnownMembership.Invite && this.room.shouldEncryptForInvitedMembers()) {
+      // make sure we are tracking the deviceList for this user
+      this.olmMachine.updateTrackedUsers([new UserId(member.userId)]).catch(e => {
+        this.prefixedLogger.error("Unable to update tracked users", e);
+      });
+    }
+
+    // TODO: handle leaves (including our own)
+  }
+
+  /**
+   * Prepare to encrypt events in this room.
+   *
+   * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices
+   * in the room.
+   * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+   * will not send encrypted messages to unverified devices.
+   * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+   * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+   */
+  prepareForEncryption(globalBlacklistUnverifiedDevices, deviceIsolationMode) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      // We consider a prepareForEncryption as an encryption promise as it will potentially share keys
+      // even if it doesn't send an event.
+      // Usually this is called when the user starts typing, so we want to make sure we have keys ready when the
+      // message is finally sent.
+      // If `encryptEvent` is invoked before `prepareForEncryption` has completed, the `encryptEvent` call will wait for
+      // `prepareForEncryption` to complete before executing.
+      // The part where `encryptEvent` shares the room key will then usually be a no-op as it was already performed by `prepareForEncryption`.
+      yield _this.encryptEvent(null, globalBlacklistUnverifiedDevices, deviceIsolationMode);
+    })();
+  }
+
+  /**
+   * Encrypt an event for this room, or prepare for encryption.
+   *
+   * This will ensure that we have a megolm session for this room, share it with the devices in the room, and
+   * then, if an event is provided, encrypt it using the session.
+   *
+   * @param event - Event to be encrypted, or null if only preparing for encryption (in which case we will pre-share the room key).
+   * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+   * will not send encrypted messages to unverified devices.
+   * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+   * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+   */
+  encryptEvent(event, globalBlacklistUnverifiedDevices, deviceIsolationMode) {
+    var _event$getTxnId,
+      _this2 = this;
+    var logger = new LogSpan(this.prefixedLogger, event ? (_event$getTxnId = event.getTxnId()) !== null && _event$getTxnId !== void 0 ? _event$getTxnId : "" : "prepareForEncryption");
+    // Ensure order of encryption to avoid message ordering issues, as the scheduler only ensures
+    // events order after they have been encrypted.
+    var prom = this.currentEncryptionPromise.catch(() => {
+      // Any errors in the previous call will have been reported already, so there is nothing to do here.
+      // we just throw away the error and start anew.
+    }).then(/*#__PURE__*/_asyncToGenerator(function* () {
+      yield logDuration(logger, "ensureEncryptionSession", /*#__PURE__*/_asyncToGenerator(function* () {
+        yield _this2.ensureEncryptionSession(logger, globalBlacklistUnverifiedDevices, deviceIsolationMode);
+      }));
+      if (event) {
+        yield logDuration(logger, "encryptEventInner", /*#__PURE__*/_asyncToGenerator(function* () {
+          yield _this2.encryptEventInner(logger, event);
+        }));
+      }
+    }));
+    this.currentEncryptionPromise = prom;
+    return prom;
+  }
+
+  /**
+   * Prepare to encrypt events in this room.
+   *
+   * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices
+   * in the room.
+   *
+   * @param logger - a place to write diagnostics to
+   * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,
+   * will not send encrypted messages to unverified devices.
+   * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.
+   * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.
+   */
+  ensureEncryptionSession(logger, globalBlacklistUnverifiedDevices, deviceIsolationMode) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      if (_this3.encryptionSettings.algorithm !== "m.megolm.v1.aes-sha2") {
+        throw new Error("Cannot encrypt in ".concat(_this3.room.roomId, " for unsupported algorithm '").concat(_this3.encryptionSettings.algorithm, "'"));
+      }
+      logger.debug("Starting encryption");
+      var members = yield _this3.room.getEncryptionTargetMembers();
+
+      // If this is the first time we are sending a message to the room, we may not yet have seen all the members
+      // (so the Crypto SDK might not have a device list for them). So, if this is the first time we are encrypting
+      // for this room, give the SDK the full list of members, to be on the safe side.
+      //
+      // This could end up being racy (if two calls to ensureEncryptionSession happen at the same time), but that's
+      // not a particular problem, since `OlmMachine.updateTrackedUsers` just adds any users that weren't already tracked.
+      if (!_this3.lazyLoadedMembersResolved) {
+        yield logDuration(_this3.prefixedLogger, "loadMembersIfNeeded: updateTrackedUsers", /*#__PURE__*/_asyncToGenerator(function* () {
+          yield _this3.olmMachine.updateTrackedUsers(members.map(u => new RustSdkCryptoJs.UserId(u.userId)));
+        }));
+        logger.debug("Updated tracked users");
+        _this3.lazyLoadedMembersResolved = true;
+
+        // Query keys in case we don't have them for newly tracked members.
+        // It's important after loading members for the first time, as likely most of them won't be
+        // known yet and will be unable to decrypt messages despite being in the room for long.
+        // This must be done before ensuring sessions. If not the devices of these users are not
+        // known yet and will not get the room key.
+        // We don't have API to only get the keys queries related to this member list, so we just
+        // process the pending requests from the olmMachine. (usually these are processed
+        // at the end of the sync, but we can't wait for that).
+        // XXX future improvement process only KeysQueryRequests for the users that have never been queried.
+        logger.debug("Processing outgoing requests");
+        yield logDuration(_this3.prefixedLogger, "doProcessOutgoingRequests", /*#__PURE__*/_asyncToGenerator(function* () {
+          yield _this3.outgoingRequestManager.doProcessOutgoingRequests();
+        }));
+      } else {
+        // If members are already loaded it's less critical to await on key queries.
+        // We might still want to trigger a processOutgoingRequests here.
+        // The call to `ensureSessionsForUsers` below will wait a bit on in-flight key queries we are
+        // interested in. If a sync handling happens in the meantime, and some new members are added to the room
+        // or have new devices it would give us a chance to query them before sending.
+        // It's less critical due to the racy nature of this process.
+        logger.debug("Processing outgoing requests in background");
+        _this3.outgoingRequestManager.doProcessOutgoingRequests();
+      }
+      logger.debug("Encrypting for users (shouldEncryptForInvitedMembers: ".concat(_this3.room.shouldEncryptForInvitedMembers(), "):"), members.map(u => "".concat(u.userId, " (").concat(u.membership, ")")));
+      var userList = members.map(u => new UserId(u.userId));
+      yield logDuration(_this3.prefixedLogger, "ensureSessionsForUsers", /*#__PURE__*/_asyncToGenerator(function* () {
+        yield _this3.keyClaimManager.ensureSessionsForUsers(logger, userList);
+      }));
+      var rustEncryptionSettings = new EncryptionSettings();
+      rustEncryptionSettings.historyVisibility = toRustHistoryVisibility(_this3.room.getHistoryVisibility());
+
+      // We only support megolm
+      rustEncryptionSettings.algorithm = EncryptionAlgorithm.MegolmV1AesSha2;
+
+      // We need to convert the rotation period from milliseconds to microseconds
+      // See https://spec.matrix.org/v1.8/client-server-api/#mroomencryption and
+      // https://matrix-org.github.io/matrix-rust-sdk-crypto-wasm/classes/EncryptionSettings.html#rotationPeriod
+      if (typeof _this3.encryptionSettings.rotation_period_ms === "number") {
+        rustEncryptionSettings.rotationPeriod = BigInt(_this3.encryptionSettings.rotation_period_ms * 1000);
+      }
+      if (typeof _this3.encryptionSettings.rotation_period_msgs === "number") {
+        rustEncryptionSettings.rotationPeriodMessages = BigInt(_this3.encryptionSettings.rotation_period_msgs);
+      }
+      switch (deviceIsolationMode.kind) {
+        case DeviceIsolationModeKind.AllDevicesIsolationMode:
+          {
+            var _this3$room$getBlackl;
+            // When this.room.getBlacklistUnverifiedDevices() === null, the global settings should be used
+            // See Room#getBlacklistUnverifiedDevices
+            var onlyAllowTrustedDevices = (_this3$room$getBlackl = _this3.room.getBlacklistUnverifiedDevices()) !== null && _this3$room$getBlackl !== void 0 ? _this3$room$getBlackl : globalBlacklistUnverifiedDevices;
+            rustEncryptionSettings.sharingStrategy = CollectStrategy.deviceBasedStrategy(onlyAllowTrustedDevices, deviceIsolationMode.errorOnVerifiedUserProblems);
+          }
+          break;
+        case DeviceIsolationModeKind.OnlySignedDevicesIsolationMode:
+          rustEncryptionSettings.sharingStrategy = CollectStrategy.identityBasedStrategy();
+          break;
+      }
+      yield logDuration(_this3.prefixedLogger, "shareRoomKey", /*#__PURE__*/_asyncToGenerator(function* () {
+        var shareMessages = yield _this3.olmMachine.shareRoomKey(new RoomId(_this3.room.roomId),
+        // safe to pass without cloning, as it's not reused here (before or after)
+        userList, rustEncryptionSettings);
+        if (shareMessages) {
+          for (var m of shareMessages) {
+            yield _this3.outgoingRequestManager.outgoingRequestProcessor.makeOutgoingRequest(m);
+          }
+        }
+      }));
+    })();
+  }
+
+  /**
+   * Discard any existing group session for this room
+   */
+  forceDiscardSession() {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      var r = yield _this4.olmMachine.invalidateGroupSession(new RoomId(_this4.room.roomId));
+      if (r) {
+        _this4.prefixedLogger.info("Discarded existing group session");
+      }
+    })();
+  }
+  encryptEventInner(logger, event) {
+    var _this5 = this;
+    return _asyncToGenerator(function* () {
+      logger.debug("Encrypting actual message content");
+      var encryptedContent = yield _this5.olmMachine.encryptRoomEvent(new RoomId(_this5.room.roomId), event.getType(), JSON.stringify(event.getContent()));
+      event.makeEncrypted(EventType.RoomMessageEncrypted, JSON.parse(encryptedContent), _this5.olmMachine.identityKeys.curve25519.toBase64(), _this5.olmMachine.identityKeys.ed25519.toBase64());
+      logger.debug("Encrypted event successfully");
+    })();
+  }
+}
+
+/**
+ * Convert a HistoryVisibility to a RustHistoryVisibility
+ * @param visibility - HistoryVisibility enum
+ * @returns a RustHistoryVisibility enum
+ */
+export function toRustHistoryVisibility(visibility) {
+  switch (visibility) {
+    case HistoryVisibility.Invited:
+      return RustHistoryVisibility.Invited;
+    case HistoryVisibility.Joined:
+      return RustHistoryVisibility.Joined;
+    case HistoryVisibility.Shared:
+      return RustHistoryVisibility.Shared;
+    case HistoryVisibility.WorldReadable:
+      return RustHistoryVisibility.WorldReadable;
+  }
+}
+//# sourceMappingURL=RoomEncryptor.js.map

package/lib/rust-crypto/RoomEncryptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoomEncryptor.js","names":["RustSdkCryptoJs","CollectStrategy","EncryptionAlgorithm","EncryptionSettings","HistoryVisibility","RustHistoryVisibility","RoomId","UserId","EventType","logger","LogSpan","logDuration","KnownMembership","DeviceIsolationModeKind","RoomEncryptor","constructor","olmMachine","keyClaimManager","outgoingRequestManager","room","encryptionSettings","_defineProperty","Promise","resolve","prefixedLogger","getChild","concat","roomId","members","getJoinedMembers","updateTrackedUsers","map","u","userId","catch","e","error","onCryptoEvent","config","JSON","stringify","Error","onRoomMembership","member","membership","Join","Invite","shouldEncryptForInvitedMembers","prepareForEncryption","globalBlacklistUnverifiedDevices","deviceIsolationMode","_this","_asyncToGenerator","encryptEvent","event","_event$getTxnId","_this2","getTxnId","prom","currentEncryptionPromise","then","ensureEncryptionSession","encryptEventInner","_this3","algorithm","debug","getEncryptionTargetMembers","lazyLoadedMembersResolved","doProcessOutgoingRequests","userList","ensureSessionsForUsers","rustEncryptionSettings","historyVisibility","toRustHistoryVisibility","getHistoryVisibility","MegolmV1AesSha2","rotation_period_ms","rotationPeriod","BigInt","rotation_period_msgs","rotationPeriodMessages","kind","AllDevicesIsolationMode","_this3$room$getBlackl","onlyAllowTrustedDevices","getBlacklistUnverifiedDevices","sharingStrategy","deviceBasedStrategy","errorOnVerifiedUserProblems","OnlySignedDevicesIsolationMode","identityBasedStrategy","shareMessages","shareRoomKey","m","outgoingRequestProcessor","makeOutgoingRequest","forceDiscardSession","_this4","r","invalidateGroupSession","info","_this5","encryptedContent","encryptRoomEvent","getType","getContent","makeEncrypted","RoomMessageEncrypted","parse","identityKeys","curve25519","toBase64","ed25519","visibility","Invited","Joined","Shared","WorldReadable"],"sources":["../../src/rust-crypto/RoomEncryptor.ts"],"sourcesContent":["/*\nCopyright 2023 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 * as RustSdkCryptoJs from \"@matrix-org/matrix-sdk-crypto-wasm\";\nimport {\n    CollectStrategy,\n    EncryptionAlgorithm,\n    EncryptionSettings,\n    HistoryVisibility as RustHistoryVisibility,\n    OlmMachine,\n    RoomId,\n    ToDeviceRequest,\n    UserId,\n} from \"@matrix-org/matrix-sdk-crypto-wasm\";\n\nimport { EventType } from \"../@types/event.ts\";\nimport { IContent, MatrixEvent } from \"../models/event.ts\";\nimport { Room } from \"../models/room.ts\";\nimport { Logger, logger, LogSpan } from \"../logger.ts\";\nimport { KeyClaimManager } from \"./KeyClaimManager.ts\";\nimport { RoomMember } from \"../models/room-member.ts\";\nimport { HistoryVisibility } from \"../@types/partials.ts\";\nimport { OutgoingRequestsManager } from \"./OutgoingRequestsManager.ts\";\nimport { logDuration } from \"../utils.ts\";\nimport { KnownMembership } from \"../@types/membership.ts\";\nimport { DeviceIsolationMode, DeviceIsolationModeKind } from \"../crypto-api/index.ts\";\n\n/**\n * RoomEncryptor: responsible for encrypting messages to a given room\n *\n * @internal\n */\nexport class RoomEncryptor {\n    private readonly prefixedLogger: Logger;\n\n    /** whether the room members have been loaded and tracked for the first time */\n    private lazyLoadedMembersResolved = false;\n\n    /**\n     * Ensures that there is only one encryption operation at a time for that room.\n     *\n     * An encryption operation is either a {@link prepareForEncryption} or an {@link encryptEvent} call.\n     */\n    private currentEncryptionPromise: Promise<void> = Promise.resolve();\n\n    /**\n     * @param olmMachine - The rust-sdk's OlmMachine\n     * @param keyClaimManager - Our KeyClaimManager, which manages the queue of one-time-key claim requests\n     * @param outgoingRequestManager - The OutgoingRequestManager, which manages the queue of outgoing requests.\n     * @param room - The room we want to encrypt for\n     * @param encryptionSettings - body of the m.room.encryption event currently in force in this room\n     */\n    public constructor(\n        private readonly olmMachine: OlmMachine,\n        private readonly keyClaimManager: KeyClaimManager,\n        private readonly outgoingRequestManager: OutgoingRequestsManager,\n        private readonly room: Room,\n        private encryptionSettings: IContent,\n    ) {\n        this.prefixedLogger = logger.getChild(`[${room.roomId} encryption]`);\n\n        // start tracking devices for any users already known to be in this room.\n        // Do not load members here, would defeat lazy loading.\n        const members = room.getJoinedMembers();\n\n        // At this point just mark the known members as tracked, it might not be the full list of members\n        // because of lazy loading. This is fine, because we will get a member list update when sending a message for\n        // the first time, see `RoomEncryptor#ensureEncryptionSession`\n        this.olmMachine\n            .updateTrackedUsers(members.map((u) => new RustSdkCryptoJs.UserId(u.userId)))\n            .catch((e) => this.prefixedLogger.error(\"Error initializing tracked users\", e));\n    }\n\n    /**\n     * Handle a new `m.room.encryption` event in this room\n     *\n     * @param config - The content of the encryption event\n     */\n    public onCryptoEvent(config: IContent): void {\n        if (JSON.stringify(this.encryptionSettings) != JSON.stringify(config)) {\n            // This should currently be unreachable, since the Rust SDK will reject any attempts to change config.\n            throw new Error(\"Cannot reconfigure an active RoomEncryptor\");\n        }\n    }\n\n    /**\n     * Handle a new `m.room.member` event in this room\n     *\n     * @param member - new membership state\n     */\n    public onRoomMembership(member: RoomMember): void {\n        if (\n            member.membership == KnownMembership.Join ||\n            (member.membership == KnownMembership.Invite && this.room.shouldEncryptForInvitedMembers())\n        ) {\n            // make sure we are tracking the deviceList for this user\n            this.olmMachine.updateTrackedUsers([new UserId(member.userId)]).catch((e) => {\n                this.prefixedLogger.error(\"Unable to update tracked users\", e);\n            });\n        }\n\n        // TODO: handle leaves (including our own)\n    }\n\n    /**\n     * Prepare to encrypt events in this room.\n     *\n     * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices\n     * in the room.\n     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,\n     * will not send encrypted messages to unverified devices.\n     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.\n     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.\n     */\n    public async prepareForEncryption(\n        globalBlacklistUnverifiedDevices: boolean,\n        deviceIsolationMode: DeviceIsolationMode,\n    ): Promise<void> {\n        // We consider a prepareForEncryption as an encryption promise as it will potentially share keys\n        // even if it doesn't send an event.\n        // Usually this is called when the user starts typing, so we want to make sure we have keys ready when the\n        // message is finally sent.\n        // If `encryptEvent` is invoked before `prepareForEncryption` has completed, the `encryptEvent` call will wait for\n        // `prepareForEncryption` to complete before executing.\n        // The part where `encryptEvent` shares the room key will then usually be a no-op as it was already performed by `prepareForEncryption`.\n        await this.encryptEvent(null, globalBlacklistUnverifiedDevices, deviceIsolationMode);\n    }\n\n    /**\n     * Encrypt an event for this room, or prepare for encryption.\n     *\n     * This will ensure that we have a megolm session for this room, share it with the devices in the room, and\n     * then, if an event is provided, encrypt it using the session.\n     *\n     * @param event - Event to be encrypted, or null if only preparing for encryption (in which case we will pre-share the room key).\n     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,\n     * will not send encrypted messages to unverified devices.\n     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.\n     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.\n     */\n    public encryptEvent(\n        event: MatrixEvent | null,\n        globalBlacklistUnverifiedDevices: boolean,\n        deviceIsolationMode: DeviceIsolationMode,\n    ): Promise<void> {\n        const logger = new LogSpan(this.prefixedLogger, event ? (event.getTxnId() ?? \"\") : \"prepareForEncryption\");\n        // Ensure order of encryption to avoid message ordering issues, as the scheduler only ensures\n        // events order after they have been encrypted.\n        const prom = this.currentEncryptionPromise\n            .catch(() => {\n                // Any errors in the previous call will have been reported already, so there is nothing to do here.\n                // we just throw away the error and start anew.\n            })\n            .then(async () => {\n                await logDuration(logger, \"ensureEncryptionSession\", async () => {\n                    await this.ensureEncryptionSession(logger, globalBlacklistUnverifiedDevices, deviceIsolationMode);\n                });\n                if (event) {\n                    await logDuration(logger, \"encryptEventInner\", async () => {\n                        await this.encryptEventInner(logger, event);\n                    });\n                }\n            });\n\n        this.currentEncryptionPromise = prom;\n        return prom;\n    }\n\n    /**\n     * Prepare to encrypt events in this room.\n     *\n     * This ensures that we have a megolm session ready to use and that we have shared its key with all the devices\n     * in the room.\n     *\n     * @param logger - a place to write diagnostics to\n     * @param globalBlacklistUnverifiedDevices - When `true`, and `deviceIsolationMode` is `AllDevicesIsolationMode`,\n     * will not send encrypted messages to unverified devices.\n     * Ignored when `deviceIsolationMode` is `OnlySignedDevicesIsolationMode`.\n     * @param deviceIsolationMode - The device isolation mode. See {@link DeviceIsolationMode}.\n     */\n    private async ensureEncryptionSession(\n        logger: LogSpan,\n        globalBlacklistUnverifiedDevices: boolean,\n        deviceIsolationMode: DeviceIsolationMode,\n    ): Promise<void> {\n        if (this.encryptionSettings.algorithm !== \"m.megolm.v1.aes-sha2\") {\n            throw new Error(\n                `Cannot encrypt in ${this.room.roomId} for unsupported algorithm '${this.encryptionSettings.algorithm}'`,\n            );\n        }\n        logger.debug(\"Starting encryption\");\n\n        const members = await this.room.getEncryptionTargetMembers();\n\n        // If this is the first time we are sending a message to the room, we may not yet have seen all the members\n        // (so the Crypto SDK might not have a device list for them). So, if this is the first time we are encrypting\n        // for this room, give the SDK the full list of members, to be on the safe side.\n        //\n        // This could end up being racy (if two calls to ensureEncryptionSession happen at the same time), but that's\n        // not a particular problem, since `OlmMachine.updateTrackedUsers` just adds any users that weren't already tracked.\n        if (!this.lazyLoadedMembersResolved) {\n            await logDuration(this.prefixedLogger, \"loadMembersIfNeeded: updateTrackedUsers\", async () => {\n                await this.olmMachine.updateTrackedUsers(members.map((u) => new RustSdkCryptoJs.UserId(u.userId)));\n            });\n            logger.debug(`Updated tracked users`);\n            this.lazyLoadedMembersResolved = true;\n\n            // Query keys in case we don't have them for newly tracked members.\n            // It's important after loading members for the first time, as likely most of them won't be\n            // known yet and will be unable to decrypt messages despite being in the room for long.\n            // This must be done before ensuring sessions. If not the devices of these users are not\n            // known yet and will not get the room key.\n            // We don't have API to only get the keys queries related to this member list, so we just\n            // process the pending requests from the olmMachine. (usually these are processed\n            // at the end of the sync, but we can't wait for that).\n            // XXX future improvement process only KeysQueryRequests for the users that have never been queried.\n            logger.debug(`Processing outgoing requests`);\n\n            await logDuration(this.prefixedLogger, \"doProcessOutgoingRequests\", async () => {\n                await this.outgoingRequestManager.doProcessOutgoingRequests();\n            });\n        } else {\n            // If members are already loaded it's less critical to await on key queries.\n            // We might still want to trigger a processOutgoingRequests here.\n            // The call to `ensureSessionsForUsers` below will wait a bit on in-flight key queries we are\n            // interested in. If a sync handling happens in the meantime, and some new members are added to the room\n            // or have new devices it would give us a chance to query them before sending.\n            // It's less critical due to the racy nature of this process.\n            logger.debug(`Processing outgoing requests in background`);\n            this.outgoingRequestManager.doProcessOutgoingRequests();\n        }\n\n        logger.debug(\n            `Encrypting for users (shouldEncryptForInvitedMembers: ${this.room.shouldEncryptForInvitedMembers()}):`,\n            members.map((u) => `${u.userId} (${u.membership})`),\n        );\n\n        const userList = members.map((u) => new UserId(u.userId));\n\n        await logDuration(this.prefixedLogger, \"ensureSessionsForUsers\", async () => {\n            await this.keyClaimManager.ensureSessionsForUsers(logger, userList);\n        });\n\n        const rustEncryptionSettings = new EncryptionSettings();\n        rustEncryptionSettings.historyVisibility = toRustHistoryVisibility(this.room.getHistoryVisibility());\n\n        // We only support megolm\n        rustEncryptionSettings.algorithm = EncryptionAlgorithm.MegolmV1AesSha2;\n\n        // We need to convert the rotation period from milliseconds to microseconds\n        // See https://spec.matrix.org/v1.8/client-server-api/#mroomencryption and\n        // https://matrix-org.github.io/matrix-rust-sdk-crypto-wasm/classes/EncryptionSettings.html#rotationPeriod\n        if (typeof this.encryptionSettings.rotation_period_ms === \"number\") {\n            rustEncryptionSettings.rotationPeriod = BigInt(this.encryptionSettings.rotation_period_ms * 1000);\n        }\n\n        if (typeof this.encryptionSettings.rotation_period_msgs === \"number\") {\n            rustEncryptionSettings.rotationPeriodMessages = BigInt(this.encryptionSettings.rotation_period_msgs);\n        }\n\n        switch (deviceIsolationMode.kind) {\n            case DeviceIsolationModeKind.AllDevicesIsolationMode:\n                {\n                    // When this.room.getBlacklistUnverifiedDevices() === null, the global settings should be used\n                    // See Room#getBlacklistUnverifiedDevices\n                    const onlyAllowTrustedDevices =\n                        this.room.getBlacklistUnverifiedDevices() ?? globalBlacklistUnverifiedDevices;\n                    rustEncryptionSettings.sharingStrategy = CollectStrategy.deviceBasedStrategy(\n                        onlyAllowTrustedDevices,\n                        deviceIsolationMode.errorOnVerifiedUserProblems,\n                    );\n                }\n                break;\n            case DeviceIsolationModeKind.OnlySignedDevicesIsolationMode:\n                rustEncryptionSettings.sharingStrategy = CollectStrategy.identityBasedStrategy();\n                break;\n        }\n\n        await logDuration(this.prefixedLogger, \"shareRoomKey\", async () => {\n            const shareMessages: ToDeviceRequest[] = await this.olmMachine.shareRoomKey(\n                new RoomId(this.room.roomId),\n                // safe to pass without cloning, as it's not reused here (before or after)\n                userList,\n                rustEncryptionSettings,\n            );\n            if (shareMessages) {\n                for (const m of shareMessages) {\n                    await this.outgoingRequestManager.outgoingRequestProcessor.makeOutgoingRequest(m);\n                }\n            }\n        });\n    }\n\n    /**\n     * Discard any existing group session for this room\n     */\n    public async forceDiscardSession(): Promise<void> {\n        const r = await this.olmMachine.invalidateGroupSession(new RoomId(this.room.roomId));\n        if (r) {\n            this.prefixedLogger.info(\"Discarded existing group session\");\n        }\n    }\n\n    private async encryptEventInner(logger: LogSpan, event: MatrixEvent): Promise<void> {\n        logger.debug(\"Encrypting actual message content\");\n        const encryptedContent = await this.olmMachine.encryptRoomEvent(\n            new RoomId(this.room.roomId),\n            event.getType(),\n            JSON.stringify(event.getContent()),\n        );\n\n        event.makeEncrypted(\n            EventType.RoomMessageEncrypted,\n            JSON.parse(encryptedContent),\n            this.olmMachine.identityKeys.curve25519.toBase64(),\n            this.olmMachine.identityKeys.ed25519.toBase64(),\n        );\n\n        logger.debug(\"Encrypted event successfully\");\n    }\n}\n\n/**\n * Convert a HistoryVisibility to a RustHistoryVisibility\n * @param visibility - HistoryVisibility enum\n * @returns a RustHistoryVisibility enum\n */\nexport function toRustHistoryVisibility(visibility: HistoryVisibility): RustHistoryVisibility {\n    switch (visibility) {\n        case HistoryVisibility.Invited:\n            return RustHistoryVisibility.Invited;\n        case HistoryVisibility.Joined:\n            return RustHistoryVisibility.Joined;\n        case HistoryVisibility.Shared:\n            return RustHistoryVisibility.Shared;\n        case HistoryVisibility.WorldReadable:\n            return RustHistoryVisibility.WorldReadable;\n    }\n}\n"],"mappings":"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","ignoreList":[]}