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

package/src/crypto/SecretSharing.ts

@@ -1,240 +0,0 @@
-/*
-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

@@ -1,136 +0,0 @@
-/*
-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

@@ -1,23 +0,0 @@
-/*
-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

@@ -1,236 +0,0 @@
-/*
-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

@@ -1,20 +0,0 @@
-/*
-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";