@unwanted/matrix-sdk-mini 34.12.0-1

package/src/crypto/SecretSharing.ts

@@ -0,0 +1,240 @@
+/*
+Copyright 2019-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 { v4 as uuidv4 } from "uuid";
+
+import { MatrixClient } from "../client.ts";
+import { ICryptoCallbacks, IEncryptedContent } from "./index.ts";
+import { defer, IDeferred } from "../utils.ts";
+import { ToDeviceMessageId } from "../@types/event.ts";
+import { logger } from "../logger.ts";
+import { MatrixEvent } from "../models/event.ts";
+import * as olmlib from "./olmlib.ts";
+
+export interface ISecretRequest {
+    requestId: string;
+    promise: Promise<string>;
+    cancel: (reason: string) => void;
+}
+
+interface ISecretRequestInternal {
+    name: string;
+    devices: string[];
+    deferred: IDeferred<string>;
+}
+
+export class SecretSharing {
+    private requests = new Map<string, ISecretRequestInternal>();
+
+    public constructor(
+        private readonly baseApis: MatrixClient,
+        private readonly cryptoCallbacks: ICryptoCallbacks,
+    ) {}
+
+    /**
+     * Request a secret from another device
+     *
+     * @param name - the name of the secret to request
+     * @param devices - the devices to request the secret from
+     */
+    public request(name: string, devices: string[]): ISecretRequest {
+        const requestId = this.baseApis.makeTxnId();
+
+        const deferred = defer<string>();
+        this.requests.set(requestId, { name, devices, deferred });
+
+        const cancel = (reason: string): void => {
+            // send cancellation event
+            const cancelData = {
+                action: "request_cancellation",
+                requesting_device_id: this.baseApis.deviceId,
+                request_id: requestId,
+            };
+            const toDevice: Map<string, typeof cancelData> = new Map();
+            for (const device of devices) {
+                toDevice.set(device, cancelData);
+            }
+            this.baseApis.sendToDevice("m.secret.request", new Map([[this.baseApis.getUserId()!, toDevice]]));
+
+            // and reject the promise so that anyone waiting on it will be
+            // notified
+            deferred.reject(new Error(reason || "Cancelled"));
+        };
+
+        // send request to devices
+        const requestData = {
+            name,
+            action: "request",
+            requesting_device_id: this.baseApis.deviceId,
+            request_id: requestId,
+            [ToDeviceMessageId]: uuidv4(),
+        };
+        const toDevice: Map<string, typeof requestData> = new Map();
+        for (const device of devices) {
+            toDevice.set(device, requestData);
+        }
+        logger.info(`Request secret ${name} from ${devices}, id ${requestId}`);
+        this.baseApis.sendToDevice("m.secret.request", new Map([[this.baseApis.getUserId()!, toDevice]]));
+
+        return {
+            requestId,
+            promise: deferred.promise,
+            cancel,
+        };
+    }
+
+    public async onRequestReceived(event: MatrixEvent): Promise<void> {
+        const sender = event.getSender();
+        const content = event.getContent();
+        if (
+            sender !== this.baseApis.getUserId() ||
+            !(content.name && content.action && content.requesting_device_id && content.request_id)
+        ) {
+            // ignore requests from anyone else, for now
+            return;
+        }
+        const deviceId = content.requesting_device_id;
+        // check if it's a cancel
+        if (content.action === "request_cancellation") {
+            /*
+            Looks like we intended to emit events when we got cancelations, but
+            we never put anything in the _incomingRequests object, and the request
+            itself doesn't use events anyway so if we were to wire up cancellations,
+            they probably ought to use the same callback interface. I'm leaving them
+            disabled for now while converting this file to typescript.
+            if (this._incomingRequests[deviceId]
+                && this._incomingRequests[deviceId][content.request_id]) {
+                logger.info(
+                    "received request cancellation for secret (" + sender +
+                    ", " + deviceId + ", " + content.request_id + ")",
+                );
+                this.baseApis.emit("crypto.secrets.requestCancelled", {
+                    user_id: sender,
+                    device_id: deviceId,
+                    request_id: content.request_id,
+                });
+            }
+            */
+        } else if (content.action === "request") {
+            if (deviceId === this.baseApis.deviceId) {
+                // no point in trying to send ourself the secret
+                return;
+            }
+
+            // check if we have the secret
+            logger.info("received request for secret (" + sender + ", " + deviceId + ", " + content.request_id + ")");
+            if (!this.cryptoCallbacks.onSecretRequested) {
+                return;
+            }
+            const secret = await this.cryptoCallbacks.onSecretRequested(
+                sender,
+                deviceId,
+                content.request_id,
+                content.name,
+                this.baseApis.checkDeviceTrust(sender, deviceId),
+            );
+            if (secret) {
+                logger.info(`Preparing ${content.name} secret for ${deviceId}`);
+                const payload = {
+                    type: "m.secret.send",
+                    content: {
+                        request_id: content.request_id,
+                        secret: secret,
+                    },
+                };
+                const encryptedContent: IEncryptedContent = {
+                    algorithm: olmlib.OLM_ALGORITHM,
+                    sender_key: this.baseApis.crypto!.olmDevice.deviceCurve25519Key!,
+                    ciphertext: {},
+                    [ToDeviceMessageId]: uuidv4(),
+                };
+                await olmlib.ensureOlmSessionsForDevices(
+                    this.baseApis.crypto!.olmDevice,
+                    this.baseApis,
+                    new Map([[sender, [this.baseApis.getStoredDevice(sender, deviceId)!]]]),
+                );
+                await olmlib.encryptMessageForDevice(
+                    encryptedContent.ciphertext,
+                    this.baseApis.getUserId()!,
+                    this.baseApis.deviceId!,
+                    this.baseApis.crypto!.olmDevice,
+                    sender,
+                    this.baseApis.getStoredDevice(sender, deviceId)!,
+                    payload,
+                );
+                const contentMap = new Map([[sender, new Map([[deviceId, encryptedContent]])]]);
+
+                logger.info(`Sending ${content.name} secret for ${deviceId}`);
+                this.baseApis.sendToDevice("m.room.encrypted", contentMap);
+            } else {
+                logger.info(`Request denied for ${content.name} secret for ${deviceId}`);
+            }
+        }
+    }
+
+    public onSecretReceived(event: MatrixEvent): void {
+        if (event.getSender() !== this.baseApis.getUserId()) {
+            // we shouldn't be receiving secrets from anyone else, so ignore
+            // because someone could be trying to send us bogus data
+            return;
+        }
+
+        if (!olmlib.isOlmEncrypted(event)) {
+            logger.error("secret event not properly encrypted");
+            return;
+        }
+
+        const content = event.getContent();
+
+        const senderKeyUser = this.baseApis.crypto!.deviceList.getUserByIdentityKey(
+            olmlib.OLM_ALGORITHM,
+            event.getSenderKey() || "",
+        );
+        if (senderKeyUser !== event.getSender()) {
+            logger.error("sending device does not belong to the user it claims to be from");
+            return;
+        }
+
+        logger.log("got secret share for request", content.request_id);
+        const requestControl = this.requests.get(content.request_id);
+        if (requestControl) {
+            // make sure that the device that sent it is one of the devices that
+            // we requested from
+            const deviceInfo = this.baseApis.crypto!.deviceList.getDeviceByIdentityKey(
+                olmlib.OLM_ALGORITHM,
+                event.getSenderKey()!,
+            );
+            if (!deviceInfo) {
+                logger.log("secret share from unknown device with key", event.getSenderKey());
+                return;
+            }
+            if (!requestControl.devices.includes(deviceInfo.deviceId)) {
+                logger.log("unsolicited secret share from device", deviceInfo.deviceId);
+                return;
+            }
+            // unsure that the sender is trusted.  In theory, this check is
+            // unnecessary since we only accept secret shares from devices that
+            // we requested from, but it doesn't hurt.
+            const deviceTrust = this.baseApis.crypto!.checkDeviceInfoTrust(event.getSender()!, deviceInfo);
+            if (!deviceTrust.isVerified()) {
+                logger.log("secret share from unverified device");
+                return;
+            }
+
+            logger.log(`Successfully received secret ${requestControl.name} ` + `from ${deviceInfo.deviceId}`);
+            requestControl.deferred.resolve(content.secret);
+        }
+    }
+}

package/src/crypto/SecretStorage.ts

@@ -0,0 +1,136 @@
+/*
+Copyright 2019 - 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 { ICryptoCallbacks } from "./index.ts";
+import { MatrixEvent } from "../models/event.ts";
+import { MatrixClient } from "../client.ts";
+import {
+    SecretStorageKeyDescription,
+    SecretStorageKeyTuple,
+    SecretStorageKeyObject,
+    AddSecretStorageKeyOpts,
+    AccountDataClient,
+    ServerSideSecretStorage,
+    ServerSideSecretStorageImpl,
+} from "../secret-storage.ts";
+import { ISecretRequest, SecretSharing } from "./SecretSharing.ts";
+
+/* re-exports for backwards compatibility */
+export type {
+    AccountDataClient as IAccountDataClient,
+    SecretStorageKeyTuple,
+    SecretStorageKeyObject,
+    SECRET_STORAGE_ALGORITHM_V1_AES,
+} from "../secret-storage.ts";
+
+export type { ISecretRequest } from "./SecretSharing.ts";
+
+/**
+ * Implements Secure Secret Storage and Sharing (MSC1946)
+ *
+ * @deprecated This is just a backwards-compatibility hack which will be removed soon.
+ *    Use {@link SecretStorage.ServerSideSecretStorageImpl} from `../secret-storage` and/or {@link SecretSharing} from `./SecretSharing`.
+ */
+export class SecretStorage<B extends MatrixClient | undefined = MatrixClient> implements ServerSideSecretStorage {
+    private readonly storageImpl: ServerSideSecretStorageImpl;
+    private readonly sharingImpl: SecretSharing;
+
+    // In its pure javascript days, this was relying on some proper Javascript-style
+    // type-abuse where sometimes we'd pass in a fake client object with just the account
+    // data methods implemented, which is all this class needs unless you use the secret
+    // sharing code, so it was fine. As a low-touch TypeScript migration, we added
+    // an extra, optional param for a real matrix client, so you can not pass it as long
+    // as you don't request any secrets.
+    //
+    // Nowadays, the whole class is scheduled for destruction, once we get rid of the legacy
+    // Crypto impl that exposes it.
+    public constructor(accountDataAdapter: AccountDataClient, cryptoCallbacks: ICryptoCallbacks, baseApis: B) {
+        this.storageImpl = new ServerSideSecretStorageImpl(accountDataAdapter, cryptoCallbacks);
+        this.sharingImpl = new SecretSharing(baseApis as MatrixClient, cryptoCallbacks);
+    }
+
+    public getDefaultKeyId(): Promise<string | null> {
+        return this.storageImpl.getDefaultKeyId();
+    }
+
+    public setDefaultKeyId(keyId: string): Promise<void> {
+        return this.storageImpl.setDefaultKeyId(keyId);
+    }
+
+    /**
+     * Add a key for encrypting secrets.
+     */
+    public addKey(algorithm: string, opts: AddSecretStorageKeyOpts, keyId?: string): Promise<SecretStorageKeyObject> {
+        return this.storageImpl.addKey(algorithm, opts, keyId);
+    }
+
+    /**
+     * Get the key information for a given ID.
+     */
+    public getKey(keyId?: string | null): Promise<SecretStorageKeyTuple | null> {
+        return this.storageImpl.getKey(keyId);
+    }
+
+    /**
+     * Check whether we have a key with a given ID.
+     */
+    public hasKey(keyId?: string): Promise<boolean> {
+        return this.storageImpl.hasKey(keyId);
+    }
+
+    /**
+     * Check whether a key matches what we expect based on the key info
+     */
+    public checkKey(key: Uint8Array, info: SecretStorageKeyDescription): Promise<boolean> {
+        return this.storageImpl.checkKey(key, info);
+    }
+
+    /**
+     * Store an encrypted secret on the server
+     */
+    public store(name: string, secret: string, keys?: string[] | null): Promise<void> {
+        return this.storageImpl.store(name, secret, keys);
+    }
+
+    /**
+     * Get a secret from storage.
+     */
+    public get(name: string): Promise<string | undefined> {
+        return this.storageImpl.get(name);
+    }
+
+    /**
+     * Check if a secret is stored on the server.
+     */
+    public async isStored(name: string): Promise<Record<string, SecretStorageKeyDescription> | null> {
+        return this.storageImpl.isStored(name);
+    }
+
+    /**
+     * Request a secret from another device
+     */
+    public request(name: string, devices: string[]): ISecretRequest {
+        return this.sharingImpl.request(name, devices);
+    }
+
+    public onRequestReceived(event: MatrixEvent): Promise<void> {
+        return this.sharingImpl.onRequestReceived(event);
+    }
+
+    public onSecretReceived(event: MatrixEvent): void {
+        this.sharingImpl.onSecretReceived(event);
+    }
+}

package/src/crypto/aes.ts

@@ -0,0 +1,23 @@
+/*
+Copyright 2020 - 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 encryptAESSecretStorageItem from "../utils/encryptAESSecretStorageItem.ts";
+import decryptAESSecretStorageItem from "../utils/decryptAESSecretStorageItem.ts";
+
+// Export for backwards compatibility
+export type { AESEncryptedSecretStoragePayload as IEncryptedPayload } from "../@types/AESEncryptedSecretStoragePayload.ts";
+export { encryptAESSecretStorageItem as encryptAES, decryptAESSecretStorageItem as decryptAES };
+export { calculateKeyCheck } from "../secret-storage.ts";

package/src/crypto/algorithms/base.ts

@@ -0,0 +1,236 @@
+/*
+Copyright 2016 - 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.
+*/
+
+/**
+ * Internal module. Defines the base classes of the encryption implementations
+ */
+
+import type { IMegolmSessionData } from "../../@types/crypto.ts";
+import { MatrixClient } from "../../client.ts";
+import { Room } from "../../models/room.ts";
+import { OlmDevice } from "../OlmDevice.ts";
+import { IContent, MatrixEvent, RoomMember } from "../../matrix.ts";
+import { Crypto, IEncryptedContent, IEventDecryptionResult, IncomingRoomKeyRequest } from "../index.ts";
+import { DeviceInfo } from "../deviceinfo.ts";
+import { IRoomEncryption } from "../RoomList.ts";
+import { DeviceInfoMap } from "../DeviceList.ts";
+
+/**
+ * Map of registered encryption algorithm classes. A map from string to {@link EncryptionAlgorithm} class
+ */
+export const ENCRYPTION_CLASSES = new Map<string, new (params: IParams) => EncryptionAlgorithm>();
+
+export type DecryptionClassParams<P extends IParams = IParams> = Omit<P, "deviceId" | "config">;
+
+/**
+ * map of registered encryption algorithm classes. Map from string to {@link DecryptionAlgorithm} class
+ */
+export const DECRYPTION_CLASSES = new Map<string, new (params: DecryptionClassParams) => DecryptionAlgorithm>();
+
+export interface IParams {
+    /** The UserID for the local user */
+    userId: string;
+    /** The identifier for this device. */
+    deviceId: string;
+    /** crypto core */
+    crypto: Crypto;
+    /** olm.js wrapper */
+    olmDevice: OlmDevice;
+    /** base matrix api interface */
+    baseApis: MatrixClient;
+    /** The ID of the room we will be sending to */
+    roomId?: string;
+    /** The body of the m.room.encryption event */
+    config: IRoomEncryption & object;
+}
+
+/**
+ * base type for encryption implementations
+ */
+export abstract class EncryptionAlgorithm {
+    protected readonly userId: string;
+    protected readonly deviceId: string;
+    protected readonly crypto: Crypto;
+    protected readonly olmDevice: OlmDevice;
+    protected readonly baseApis: MatrixClient;
+
+    /**
+     * @param params - parameters
+     */
+    public constructor(params: IParams) {
+        this.userId = params.userId;
+        this.deviceId = params.deviceId;
+        this.crypto = params.crypto;
+        this.olmDevice = params.olmDevice;
+        this.baseApis = params.baseApis;
+    }
+
+    /**
+     * Perform any background tasks that can be done before a message is ready to
+     * send, in order to speed up sending of the message.
+     *
+     * @param room - the room the event is in
+     */
+    public prepareToEncrypt(room: Room): void {}
+
+    /**
+     * Encrypt a message event
+     *
+     * @public
+     *
+     * @param content - event content
+     *
+     * @returns Promise which resolves to the new event body
+     */
+    public abstract encryptMessage(room: Room, eventType: string, content: IContent): Promise<IEncryptedContent>;
+
+    /**
+     * Called when the membership of a member of the room changes.
+     *
+     * @param event -  event causing the change
+     * @param member -  user whose membership changed
+     * @param oldMembership -  previous membership
+     * @public
+     */
+    public onRoomMembership(event: MatrixEvent, member: RoomMember, oldMembership?: string): void {}
+
+    public reshareKeyWithDevice?(
+        senderKey: string,
+        sessionId: string,
+        userId: string,
+        device: DeviceInfo,
+    ): Promise<void>;
+
+    public forceDiscardSession?(): void;
+}
+
+/**
+ * base type for decryption implementations
+ */
+export abstract class DecryptionAlgorithm {
+    protected readonly userId: string;
+    protected readonly crypto: Crypto;
+    protected readonly olmDevice: OlmDevice;
+    protected readonly baseApis: MatrixClient;
+
+    public constructor(params: DecryptionClassParams) {
+        this.userId = params.userId;
+        this.crypto = params.crypto;
+        this.olmDevice = params.olmDevice;
+        this.baseApis = params.baseApis;
+    }
+
+    /**
+     * Decrypt an event
+     *
+     * @param event - undecrypted event
+     *
+     * @returns promise which
+     * resolves once we have finished decrypting. Rejects with an
+     * `algorithms.DecryptionError` if there is a problem decrypting the event.
+     */
+    public abstract decryptEvent(event: MatrixEvent): Promise<IEventDecryptionResult>;
+
+    /**
+     * Handle a key event
+     *
+     * @param params - event key event
+     */
+    public async onRoomKeyEvent(params: MatrixEvent): Promise<void> {
+        // ignore by default
+    }
+
+    /**
+     * Import a room key
+     *
+     * @param opts - object
+     */
+    public async importRoomKey(session: IMegolmSessionData, opts: object): Promise<void> {
+        // ignore by default
+    }
+
+    /**
+     * Determine if we have the keys necessary to respond to a room key request
+     *
+     * @returns true if we have the keys and could (theoretically) share
+     *  them; else false.
+     */
+    public hasKeysForKeyRequest(keyRequest: IncomingRoomKeyRequest): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+    /**
+     * Send the response to a room key request
+     *
+     */
+    public shareKeysWithDevice(keyRequest: IncomingRoomKeyRequest): void {
+        throw new Error("shareKeysWithDevice not supported for this DecryptionAlgorithm");
+    }
+
+    /**
+     * Retry decrypting all the events from a sender that haven't been
+     * decrypted yet.
+     *
+     * @param senderKey - the sender's key
+     */
+    public async retryDecryptionFromSender(senderKey: string): Promise<boolean> {
+        // ignore by default
+        return false;
+    }
+
+    public onRoomKeyWithheldEvent?(event: MatrixEvent): Promise<void>;
+    public sendSharedHistoryInboundSessions?(devicesByUser: Map<string, DeviceInfo[]>): Promise<void>;
+}
+
+export class UnknownDeviceError extends Error {
+    /**
+     * Exception thrown specifically when we want to warn the user to consider
+     * the security of their conversation before continuing
+     *
+     * @param msg - message describing the problem
+     * @param devices - set of unknown devices per user we're warning about
+     */
+    public constructor(
+        msg: string,
+        public readonly devices: DeviceInfoMap,
+        public event?: MatrixEvent,
+    ) {
+        super(msg);
+        this.name = "UnknownDeviceError";
+        this.devices = devices;
+    }
+}
+
+/**
+ * Registers an encryption/decryption class for a particular algorithm
+ *
+ * @param algorithm - algorithm tag to register for
+ *
+ * @param encryptor - {@link EncryptionAlgorithm} implementation
+ *
+ * @param decryptor - {@link DecryptionAlgorithm} implementation
+ */
+export function registerAlgorithm<P extends IParams = IParams>(
+    algorithm: string,
+    encryptor: new (params: P) => EncryptionAlgorithm,
+    decryptor: new (params: DecryptionClassParams<P>) => DecryptionAlgorithm,
+): void {
+    ENCRYPTION_CLASSES.set(algorithm, encryptor as new (params: IParams) => EncryptionAlgorithm);
+    DECRYPTION_CLASSES.set(algorithm, decryptor as new (params: DecryptionClassParams) => DecryptionAlgorithm);
+}
+
+/* Re-export for backwards compatibility. Deprecated: this is an internal class. */
+export { DecryptionError } from "../../common-crypto/CryptoBackend.ts";

package/src/crypto/algorithms/index.ts

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 - 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 "./olm.ts";
+import "./megolm.ts";
+
+export * from "./base.ts";