@unwanted/matrix-sdk-mini 34.12.0 → 34.13.0

package/src/crypto/verification/request/ToDeviceChannel.ts

@@ -1,354 +0,0 @@
-/*
-Copyright 2018 New Vector Ltd
-Copyright 2019 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 { randomString } from "../../../randomstring.ts";
-import { logger } from "../../../logger.ts";
-import {
-    CANCEL_TYPE,
-    PHASE_STARTED,
-    PHASE_READY,
-    REQUEST_TYPE,
-    READY_TYPE,
-    START_TYPE,
-    VerificationRequest,
-} from "./VerificationRequest.ts";
-import { errorFromEvent, newUnexpectedMessageError } from "../Error.ts";
-import { MatrixEvent } from "../../../models/event.ts";
-import { IVerificationChannel } from "./Channel.ts";
-import { MatrixClient } from "../../../client.ts";
-import { IRequestsMap } from "../../index.ts";
-
-export type Request = VerificationRequest<ToDeviceChannel>;
-
-/**
- * A key verification channel that sends verification events over to_device messages.
- * Generates its own transaction ids.
- */
-export class ToDeviceChannel implements IVerificationChannel {
-    public request?: VerificationRequest;
-
-    // userId and devices of user we're about to verify
-    public constructor(
-        private readonly client: MatrixClient,
-        public readonly userId: string,
-        private readonly devices: string[],
-        public transactionId?: string,
-        public deviceId?: string,
-    ) {}
-
-    public isToDevices(devices: string[]): boolean {
-        if (devices.length === this.devices.length) {
-            for (const device of devices) {
-                if (!this.devices.includes(device)) {
-                    return false;
-                }
-            }
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    public static getEventType(event: MatrixEvent): string {
-        return event.getType();
-    }
-
-    /**
-     * Extract the transaction id used by a given key verification event, if any
-     * @param event - the event
-     * @returns the transaction id
-     */
-    public static getTransactionId(event: MatrixEvent): string {
-        const content = event.getContent();
-        return content && content.transaction_id;
-    }
-
-    /**
-     * Checks whether the given event type should be allowed to initiate a new VerificationRequest over this channel
-     * @param type - the event type to check
-     * @returns boolean flag
-     */
-    public static canCreateRequest(type: string): boolean {
-        return type === REQUEST_TYPE || type === START_TYPE;
-    }
-
-    public canCreateRequest(type: string): boolean {
-        return ToDeviceChannel.canCreateRequest(type);
-    }
-
-    /**
-     * Checks whether this event is a well-formed key verification event.
-     * This only does checks that don't rely on the current state of a potentially already channel
-     * so we can prevent channels being created by invalid events.
-     * `handleEvent` can do more checks and choose to ignore invalid events.
-     * @param event - the event to validate
-     * @param client - the client to get the current user and device id from
-     * @returns whether the event is valid and should be passed to handleEvent
-     */
-    public static validateEvent(event: MatrixEvent, client: MatrixClient): boolean {
-        if (event.isCancelled()) {
-            logger.warn("Ignoring flagged verification request from " + event.getSender());
-            return false;
-        }
-        const content = event.getContent();
-        if (!content) {
-            logger.warn("ToDeviceChannel.validateEvent: invalid: no content");
-            return false;
-        }
-
-        if (!content.transaction_id) {
-            logger.warn("ToDeviceChannel.validateEvent: invalid: no transaction_id");
-            return false;
-        }
-
-        const type = event.getType();
-
-        if (type === REQUEST_TYPE) {
-            if (!Number.isFinite(content.timestamp)) {
-                logger.warn("ToDeviceChannel.validateEvent: invalid: no timestamp");
-                return false;
-            }
-            if (event.getSender() === client.getUserId() && content.from_device == client.getDeviceId()) {
-                // ignore requests from ourselves, because it doesn't make sense for a
-                // device to verify itself
-                logger.warn("ToDeviceChannel.validateEvent: invalid: from own device");
-                return false;
-            }
-        }
-
-        return VerificationRequest.validateEvent(type, event, client);
-    }
-
-    /**
-     * @param event - the event to get the timestamp of
-     * @returns the timestamp when the event was sent
-     */
-    public getTimestamp(event: MatrixEvent): number {
-        const content = event.getContent();
-        return content && content.timestamp;
-    }
-
-    /**
-     * Changes the state of the channel, request, and verifier in response to a key verification event.
-     * @param event - to handle
-     * @param request - the request to forward handling to
-     * @param isLiveEvent - whether this is an even received through sync or not
-     * @returns a promise that resolves when any requests as an answer to the passed-in event are sent.
-     */
-    public async handleEvent(event: MatrixEvent, request: Request, isLiveEvent = false): Promise<void> {
-        const type = event.getType();
-        const content = event.getContent();
-        if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-            if (!this.transactionId) {
-                this.transactionId = content.transaction_id;
-            }
-            const deviceId = content.from_device;
-            // adopt deviceId if not set before and valid
-            if (!this.deviceId && this.devices.includes(deviceId)) {
-                this.deviceId = deviceId;
-            }
-            // if no device id or different from adopted one, cancel with sender
-            if (!this.deviceId || this.deviceId !== deviceId) {
-                // also check that message came from the device we sent the request to earlier on
-                // and do send a cancel message to that device
-                // (but don't cancel the request for the device we should be talking to)
-                const cancelContent = this.completeContent(CANCEL_TYPE, errorFromEvent(newUnexpectedMessageError()));
-                return this.sendToDevices(CANCEL_TYPE, cancelContent, [deviceId]);
-            }
-        }
-        const wasStarted = request.phase === PHASE_STARTED || request.phase === PHASE_READY;
-
-        await request.handleEvent(event.getType(), event, isLiveEvent, false, false);
-
-        const isStarted = request.phase === PHASE_STARTED || request.phase === PHASE_READY;
-
-        const isAcceptingEvent = type === START_TYPE || type === READY_TYPE;
-        // the request has picked a ready or start event, tell the other devices about it
-        if (isAcceptingEvent && !wasStarted && isStarted && this.deviceId) {
-            const nonChosenDevices = this.devices.filter((d) => d !== this.deviceId && d !== this.client.getDeviceId());
-            if (nonChosenDevices.length) {
-                const message = this.completeContent(CANCEL_TYPE, {
-                    code: "m.accepted",
-                    reason: "Verification request accepted by another device",
-                });
-                await this.sendToDevices(CANCEL_TYPE, message, nonChosenDevices);
-            }
-        }
-    }
-
-    /**
-     * See {@link InRoomChannel#completedContentFromEvent} for why this is needed.
-     * @param event - the received event
-     * @returns the content object
-     */
-    public completedContentFromEvent(event: MatrixEvent): Record<string, any> {
-        return event.getContent();
-    }
-
-    /**
-     * Add all the fields to content needed for sending it over this channel.
-     * This is public so verification methods (SAS uses this) can get the exact
-     * content that will be sent independent of the used channel,
-     * as they need to calculate the hash of it.
-     * @param type - the event type
-     * @param content - the (incomplete) content
-     * @returns the complete content, as it will be sent.
-     */
-    public completeContent(type: string, content: Record<string, any>): Record<string, any> {
-        // make a copy
-        content = Object.assign({}, content);
-        if (this.transactionId) {
-            content.transaction_id = this.transactionId;
-        }
-        if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-            content.from_device = this.client.getDeviceId();
-        }
-        if (type === REQUEST_TYPE) {
-            content.timestamp = Date.now();
-        }
-        return content;
-    }
-
-    /**
-     * Send an event over the channel with the content not having gone through `completeContent`.
-     * @param type - the event type
-     * @param uncompletedContent - the (incomplete) content
-     * @returns the promise of the request
-     */
-    public send(type: string, uncompletedContent: Record<string, any> = {}): Promise<void> {
-        // create transaction id when sending request
-        if ((type === REQUEST_TYPE || type === START_TYPE) && !this.transactionId) {
-            this.transactionId = ToDeviceChannel.makeTransactionId();
-        }
-        const content = this.completeContent(type, uncompletedContent);
-        return this.sendCompleted(type, content);
-    }
-
-    /**
-     * Send an event over the channel with the content having gone through `completeContent` already.
-     * @param type - the event type
-     * @returns the promise of the request
-     */
-    public async sendCompleted(type: string, content: Record<string, any>): Promise<void> {
-        let result;
-        if (type === REQUEST_TYPE || (type === CANCEL_TYPE && !this.deviceId)) {
-            result = await this.sendToDevices(type, content, this.devices);
-        } else {
-            result = await this.sendToDevices(type, content, [this.deviceId!]);
-        }
-        // the VerificationRequest state machine requires remote echos of the event
-        // the client sends itself, so we fake this for to_device messages
-        const remoteEchoEvent = new MatrixEvent({
-            sender: this.client.getUserId()!,
-            content,
-            type,
-        });
-        await this.request!.handleEvent(
-            type,
-            remoteEchoEvent,
-            /*isLiveEvent=*/ true,
-            /*isRemoteEcho=*/ true,
-            /*isSentByUs=*/ true,
-        );
-        return result;
-    }
-
-    private async sendToDevices(type: string, content: Record<string, any>, devices: string[]): Promise<void> {
-        if (devices.length) {
-            const deviceMessages: Map<string, Record<string, any>> = new Map();
-            for (const deviceId of devices) {
-                deviceMessages.set(deviceId, content);
-            }
-
-            await this.client.sendToDevice(type, new Map([[this.userId, deviceMessages]]));
-        }
-    }
-
-    /**
-     * Allow Crypto module to create and know the transaction id before the .start event gets sent.
-     * @returns the transaction id
-     */
-    public static makeTransactionId(): string {
-        return randomString(32);
-    }
-}
-
-export class ToDeviceRequests implements IRequestsMap {
-    private requestsByUserId = new Map<string, Map<string, Request>>();
-
-    public getRequest(event: MatrixEvent): Request | undefined {
-        return this.getRequestBySenderAndTxnId(event.getSender()!, ToDeviceChannel.getTransactionId(event));
-    }
-
-    public getRequestByChannel(channel: ToDeviceChannel): Request | undefined {
-        return this.getRequestBySenderAndTxnId(channel.userId, channel.transactionId!);
-    }
-
-    public getRequestBySenderAndTxnId(sender: string, txnId: string): Request | undefined {
-        const requestsByTxnId = this.requestsByUserId.get(sender);
-        if (requestsByTxnId) {
-            return requestsByTxnId.get(txnId);
-        }
-    }
-
-    public setRequest(event: MatrixEvent, request: Request): void {
-        this.setRequestBySenderAndTxnId(event.getSender()!, ToDeviceChannel.getTransactionId(event), request);
-    }
-
-    public setRequestByChannel(channel: ToDeviceChannel, request: Request): void {
-        this.setRequestBySenderAndTxnId(channel.userId, channel.transactionId!, request);
-    }
-
-    public setRequestBySenderAndTxnId(sender: string, txnId: string, request: Request): void {
-        let requestsByTxnId = this.requestsByUserId.get(sender);
-        if (!requestsByTxnId) {
-            requestsByTxnId = new Map();
-            this.requestsByUserId.set(sender, requestsByTxnId);
-        }
-        requestsByTxnId.set(txnId, request);
-    }
-
-    public removeRequest(event: MatrixEvent): void {
-        const userId = event.getSender()!;
-        const requestsByTxnId = this.requestsByUserId.get(userId);
-        if (requestsByTxnId) {
-            requestsByTxnId.delete(ToDeviceChannel.getTransactionId(event));
-            if (requestsByTxnId.size === 0) {
-                this.requestsByUserId.delete(userId);
-            }
-        }
-    }
-
-    public findRequestInProgress(userId: string, devices: string[]): Request | undefined {
-        const requestsByTxnId = this.requestsByUserId.get(userId);
-        if (requestsByTxnId) {
-            for (const request of requestsByTxnId.values()) {
-                if (request.pending && request.channel.isToDevices(devices)) {
-                    return request;
-                }
-            }
-        }
-    }
-
-    public getRequestsInProgress(userId: string): Request[] {
-        const requestsByTxnId = this.requestsByUserId.get(userId);
-        if (requestsByTxnId) {
-            return Array.from(requestsByTxnId.values()).filter((r) => r.pending);
-        }
-        return [];
-    }
-}