@unwanted/matrix-sdk-mini 34.12.0-1

package/src/rust-crypto/KeyClaimManager.ts

@@ -0,0 +1,86 @@
+/*
+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 { OlmMachine, UserId } from "@matrix-org/matrix-sdk-crypto-wasm";
+
+import { OutgoingRequestProcessor } from "./OutgoingRequestProcessor.ts";
+import { LogSpan } from "../logger.ts";
+
+/**
+ * KeyClaimManager: linearises calls to OlmMachine.getMissingSessions to avoid races
+ *
+ * We have one of these per `RustCrypto` (and hence per `MatrixClient`).
+ *
+ * @internal
+ */
+export class KeyClaimManager {
+    private currentClaimPromise: Promise<void>;
+    private stopped = false;
+
+    public constructor(
+        private readonly olmMachine: OlmMachine,
+        private readonly outgoingRequestProcessor: OutgoingRequestProcessor,
+    ) {
+        this.currentClaimPromise = Promise.resolve();
+    }
+
+    /**
+     * Tell the KeyClaimManager to immediately stop processing requests.
+     *
+     * Any further calls, and any still in the queue, will fail with an error.
+     */
+    public stop(): void {
+        this.stopped = true;
+    }
+
+    /**
+     * Given a list of users, attempt to ensure that we have Olm Sessions active with each of their devices
+     *
+     * If we don't have an active olm session, we will claim a one-time key and start one.
+     * @param logger - logger to use
+     * @param userList - list of userIDs to claim
+     */
+    public ensureSessionsForUsers(logger: LogSpan, userList: Array<UserId>): Promise<void> {
+        // The Rust-SDK requires that we only have one getMissingSessions process in flight at once. This little dance
+        // ensures that, by only having one call to ensureSessionsForUsersInner active at once (and making them
+        // queue up in order).
+        const prom = this.currentClaimPromise
+            .catch(() => {
+                // any errors in the previous claim will have been reported already, so there is nothing to do here.
+                // we just throw away the error and start anew.
+            })
+            .then(() => this.ensureSessionsForUsersInner(logger, userList));
+        this.currentClaimPromise = prom;
+        return prom;
+    }
+
+    private async ensureSessionsForUsersInner(logger: LogSpan, userList: Array<UserId>): Promise<void> {
+        // bail out quickly if we've been stopped.
+        if (this.stopped) {
+            throw new Error(`Cannot ensure Olm sessions: shutting down`);
+        }
+        logger.info("Checking for missing Olm sessions");
+        // By passing the userId array to rust we transfer ownership of the items to rust, causing
+        // them to be invalidated on the JS side as soon as the method is called.
+        // As we haven't created the `userList` let's clone the users, to not break the caller from re-using it.
+        const claimRequest = await this.olmMachine.getMissingSessions(userList.map((u) => u.clone()));
+        if (claimRequest) {
+            logger.info("Making /keys/claim request");
+            await this.outgoingRequestProcessor.makeOutgoingRequest(claimRequest);
+        }
+        logger.info("Olm sessions prepared");
+    }
+}

package/src/rust-crypto/OutgoingRequestProcessor.ts

@@ -0,0 +1,236 @@
+/*
+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 {
+    KeysBackupRequest,
+    KeysClaimRequest,
+    KeysQueryRequest,
+    KeysUploadRequest,
+    OlmMachine,
+    PutDehydratedDeviceRequest,
+    RoomMessageRequest,
+    SignatureUploadRequest,
+    ToDeviceRequest,
+    UploadSigningKeysRequest,
+} from "@matrix-org/matrix-sdk-crypto-wasm";
+
+import { logger } from "../logger.ts";
+import { calculateRetryBackoff, IHttpOpts, MatrixHttpApi, Method } from "../http-api/index.ts";
+import { logDuration, QueryDict, sleep } from "../utils.ts";
+import { AuthDict, UIAuthCallback } from "../interactive-auth.ts";
+import { UIAResponse } from "../@types/uia.ts";
+import { ToDeviceMessageId } from "../@types/event.ts";
+import { UnstablePrefix as DehydrationUnstablePrefix } from "./DehydratedDeviceManager.ts";
+
+/**
+ * Common interface for all the request types returned by `OlmMachine.outgoingRequests`.
+ *
+ * @internal
+ */
+export interface OutgoingRequest {
+    readonly id: string | undefined;
+    readonly type: number;
+}
+
+/**
+ * OutgoingRequestManager: turns `OutgoingRequest`s from the rust sdk into HTTP requests
+ *
+ * We have one of these per `RustCrypto` (and hence per `MatrixClient`), not that it does anything terribly complicated.
+ * It's responsible for:
+ *
+ *   * holding the reference to the `MatrixHttpApi`
+ *   * turning `OutgoingRequest`s from the rust backend into HTTP requests, and sending them
+ *   * sending the results of such requests back to the rust backend.
+ *
+ * @internal
+ */
+export class OutgoingRequestProcessor {
+    public constructor(
+        private readonly olmMachine: OlmMachine,
+        private readonly http: MatrixHttpApi<IHttpOpts & { onlyData: true }>,
+    ) {}
+
+    public async makeOutgoingRequest<T>(
+        msg: OutgoingRequest | UploadSigningKeysRequest | PutDehydratedDeviceRequest,
+        uiaCallback?: UIAuthCallback<T>,
+    ): Promise<void> {
+        let resp: string;
+
+        /* refer https://docs.rs/matrix-sdk-crypto/0.6.0/matrix_sdk_crypto/requests/enum.OutgoingRequests.html
+         * for the complete list of request types
+         */
+        if (msg instanceof KeysUploadRequest) {
+            resp = await this.requestWithRetry(Method.Post, "/_matrix/client/v3/keys/upload", {}, msg.body);
+        } else if (msg instanceof KeysQueryRequest) {
+            resp = await this.requestWithRetry(Method.Post, "/_matrix/client/v3/keys/query", {}, msg.body);
+        } else if (msg instanceof KeysClaimRequest) {
+            resp = await this.requestWithRetry(Method.Post, "/_matrix/client/v3/keys/claim", {}, msg.body);
+        } else if (msg instanceof SignatureUploadRequest) {
+            resp = await this.requestWithRetry(Method.Post, "/_matrix/client/v3/keys/signatures/upload", {}, msg.body);
+        } else if (msg instanceof KeysBackupRequest) {
+            resp = await this.requestWithRetry(
+                Method.Put,
+                "/_matrix/client/v3/room_keys/keys",
+                { version: msg.version },
+                msg.body,
+            );
+        } else if (msg instanceof ToDeviceRequest) {
+            resp = await this.sendToDeviceRequest(msg);
+        } else if (msg instanceof RoomMessageRequest) {
+            const path =
+                `/_matrix/client/v3/rooms/${encodeURIComponent(msg.room_id)}/send/` +
+                `${encodeURIComponent(msg.event_type)}/${encodeURIComponent(msg.txn_id)}`;
+            resp = await this.requestWithRetry(Method.Put, path, {}, msg.body);
+        } else if (msg instanceof UploadSigningKeysRequest) {
+            await this.makeRequestWithUIA(
+                Method.Post,
+                "/_matrix/client/v3/keys/device_signing/upload",
+                {},
+                msg.body,
+                uiaCallback,
+            );
+            // SigningKeysUploadRequest does not implement OutgoingRequest and does not need to be marked as sent.
+            return;
+        } else if (msg instanceof PutDehydratedDeviceRequest) {
+            const path = DehydrationUnstablePrefix + "/dehydrated_device";
+            await this.rawJsonRequest(Method.Put, path, {}, msg.body);
+            // PutDehydratedDeviceRequest does not implement OutgoingRequest and does not need to be marked as sent.
+            return;
+        } else {
+            logger.warn("Unsupported outgoing message", Object.getPrototypeOf(msg));
+            resp = "";
+        }
+
+        if (msg.id) {
+            try {
+                await logDuration(logger, `Mark Request as sent ${msg.type}`, async () => {
+                    await this.olmMachine.markRequestAsSent(msg.id!, msg.type, resp);
+                });
+            } catch (e) {
+                // Ignore errors which are caused by the olmMachine having been freed. The exact error message depends
+                // on whether we are using a release or develop build of rust-sdk-crypto-wasm.
+                if (
+                    e instanceof Error &&
+                    (e.message === "Attempt to use a moved value" || e.message === "null pointer passed to rust")
+                ) {
+                    logger.log(`Ignoring error '${e.message}': client is likely shutting down`);
+                } else {
+                    throw e;
+                }
+            }
+        } else {
+            logger.trace(`Outgoing request type:${msg.type} does not have an ID`);
+        }
+    }
+
+    /**
+     * Send the HTTP request for a `ToDeviceRequest`
+     *
+     * @param request - request to send
+     * @returns JSON-serialized body of the response, if successful
+     */
+    private async sendToDeviceRequest(request: ToDeviceRequest): Promise<string> {
+        // a bit of extra logging, to help trace to-device messages through the system
+        const parsedBody: { messages: Record<string, Record<string, Record<string, any>>> } = JSON.parse(request.body);
+
+        const messageList = [];
+        for (const [userId, perUserMessages] of Object.entries(parsedBody.messages)) {
+            for (const [deviceId, message] of Object.entries(perUserMessages)) {
+                messageList.push(`${userId}/${deviceId} (msgid ${message[ToDeviceMessageId]})`);
+            }
+        }
+
+        logger.info(
+            `Sending batch of to-device messages. type=${request.event_type} txnid=${request.txn_id}`,
+            messageList,
+        );
+
+        const path =
+            `/_matrix/client/v3/sendToDevice/${encodeURIComponent(request.event_type)}/` +
+            encodeURIComponent(request.txn_id);
+        return await this.requestWithRetry(Method.Put, path, {}, request.body);
+    }
+
+    private async makeRequestWithUIA<T>(
+        method: Method,
+        path: string,
+        queryParams: QueryDict,
+        body: string,
+        uiaCallback: UIAuthCallback<T> | undefined,
+    ): Promise<string> {
+        if (!uiaCallback) {
+            return await this.requestWithRetry(method, path, queryParams, body);
+        }
+
+        const parsedBody = JSON.parse(body);
+        const makeRequest = async (auth: AuthDict | null): Promise<UIAResponse<T>> => {
+            const newBody: Record<string, any> = {
+                ...parsedBody,
+            };
+            if (auth !== null) {
+                newBody.auth = auth;
+            }
+            const resp = await this.requestWithRetry(method, path, queryParams, JSON.stringify(newBody));
+            return JSON.parse(resp) as T;
+        };
+
+        const resp = await uiaCallback(makeRequest);
+        return JSON.stringify(resp);
+    }
+
+    private async requestWithRetry(
+        method: Method,
+        path: string,
+        queryParams: QueryDict,
+        body: string,
+    ): Promise<string> {
+        let currentRetryCount = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            try {
+                return await this.rawJsonRequest(method, path, queryParams, body);
+            } catch (e) {
+                currentRetryCount++;
+                const backoff = calculateRetryBackoff(e, currentRetryCount, true);
+                if (backoff < 0) {
+                    // Max number of retries reached, or error is not retryable. rethrow the error
+                    throw e;
+                }
+                // wait for the specified time and then retry the request
+                await sleep(backoff);
+            }
+        }
+    }
+
+    private async rawJsonRequest(method: Method, path: string, queryParams: QueryDict, body: string): Promise<string> {
+        const opts = {
+            // inhibit the JSON stringification and parsing within HttpApi.
+            json: false,
+
+            // nevertheless, we are sending, and accept, JSON.
+            headers: {
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+
+            // we use the full prefix
+            prefix: "",
+        };
+
+        return await this.http.authedRequest<string>(method, path, queryParams, body, opts);
+    }
+}

package/src/rust-crypto/OutgoingRequestsManager.ts

@@ -0,0 +1,143 @@
+/*
+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 { OlmMachine } from "@matrix-org/matrix-sdk-crypto-wasm";
+
+import { OutgoingRequest, OutgoingRequestProcessor } from "./OutgoingRequestProcessor.ts";
+import { Logger } from "../logger.ts";
+import { defer, IDeferred, logDuration } from "../utils.ts";
+
+/**
+ * OutgoingRequestsManager: responsible for processing outgoing requests from the OlmMachine.
+ * Ensure that only one loop is going on at once, and that the requests are processed in order.
+ */
+export class OutgoingRequestsManager {
+    /** whether {@link stop} has been called */
+    private stopped = false;
+
+    /** whether {@link outgoingRequestLoop} is currently running */
+    private outgoingRequestLoopRunning = false;
+
+    /**
+     * If there are additional calls to doProcessOutgoingRequests() while there is a current call running
+     * we need to remember in order to call `doProcessOutgoingRequests` again (as there could be new requests).
+     *
+     * If this is defined, it is an indication that we need to do another iteration; in this case the deferred
+     * will resolve once that next iteration completes. If it is undefined, there have been no new calls
+     * to `doProcessOutgoingRequests` since the current iteration started.
+     */
+    private nextLoopDeferred?: IDeferred<void>;
+
+    public constructor(
+        private readonly logger: Logger,
+        private readonly olmMachine: OlmMachine,
+        public readonly outgoingRequestProcessor: OutgoingRequestProcessor,
+    ) {}
+
+    /**
+     * Shut down as soon as possible the current loop of outgoing requests processing.
+     */
+    public stop(): void {
+        this.stopped = true;
+    }
+
+    /**
+     * Process the OutgoingRequests from the OlmMachine.
+     *
+     * This should be called at the end of each sync, to process any OlmMachine OutgoingRequests created by the rust sdk.
+     * In some cases if OutgoingRequests need to be sent immediately, this can be called directly.
+     *
+     * Calls to doProcessOutgoingRequests() are processed synchronously, one after the other, in order.
+     * If doProcessOutgoingRequests() is called while another call is still being processed, it will be queued.
+     * Multiple calls to doProcessOutgoingRequests() when a call is already processing will be batched together.
+     */
+    public doProcessOutgoingRequests(): Promise<void> {
+        // Flag that we need at least one more iteration of the loop.
+        //
+        // It is important that we do this even if the loop is currently running. There is potential for a race whereby
+        // a request is added to the queue *after* `OlmMachine.outgoingRequests` checks the queue, but *before* it
+        // returns. In such a case, the item could sit there unnoticed for some time.
+        //
+        // In order to circumvent the race, we set a flag which tells the loop to go round once again even if the
+        // queue appears to be empty.
+        if (!this.nextLoopDeferred) {
+            this.nextLoopDeferred = defer();
+        }
+
+        // ... and wait for it to complete.
+        const result = this.nextLoopDeferred.promise;
+
+        // set the loop going if it is not already.
+        if (!this.outgoingRequestLoopRunning) {
+            this.outgoingRequestLoop().catch((e) => {
+                // this should not happen; outgoingRequestLoop should return any errors via `nextLoopDeferred`.
+                /* istanbul ignore next */
+                this.logger.error("Uncaught error in outgoing request loop", e);
+            });
+        }
+        return result;
+    }
+
+    private async outgoingRequestLoop(): Promise<void> {
+        /* istanbul ignore if */
+        if (this.outgoingRequestLoopRunning) {
+            throw new Error("Cannot run two outgoing request loops");
+        }
+        this.outgoingRequestLoopRunning = true;
+        try {
+            while (!this.stopped && this.nextLoopDeferred) {
+                const deferred = this.nextLoopDeferred;
+
+                // reset `nextLoopDeferred` so that any future calls to `doProcessOutgoingRequests` are queued
+                // for another additional iteration.
+                this.nextLoopDeferred = undefined;
+
+                // make the requests and feed the results back to the `nextLoopDeferred`
+                await this.processOutgoingRequests().then(deferred.resolve, deferred.reject);
+            }
+        } finally {
+            this.outgoingRequestLoopRunning = false;
+        }
+
+        if (this.nextLoopDeferred) {
+            // the loop was stopped, but there was a call to `doProcessOutgoingRequests`. Make sure that
+            // we reject the promise in case anything is waiting for it.
+            this.nextLoopDeferred.reject(new Error("OutgoingRequestsManager was stopped"));
+        }
+    }
+
+    /**
+     * Make a single request to `olmMachine.outgoingRequests` and do the corresponding requests.
+     */
+    private async processOutgoingRequests(): Promise<void> {
+        if (this.stopped) return;
+
+        const outgoingRequests: OutgoingRequest[] = await this.olmMachine.outgoingRequests();
+
+        for (const request of outgoingRequests) {
+            if (this.stopped) return;
+            try {
+                await logDuration(this.logger, `Make outgoing request ${request.type}`, async () => {
+                    await this.outgoingRequestProcessor.makeOutgoingRequest(request);
+                });
+            } catch (e) {
+                // as part of the loop we silently ignore errors, but log them.
+                // The rust sdk will retry the request later as it won't have been marked as sent.
+                this.logger.error(`Failed to process outgoing request ${request.type}: ${e}`);
+            }
+        }
+    }
+}