@unwanted/matrix-sdk-mini 34.12.0 → 34.13.0

package/src/crypto/verification/Base.ts

@@ -1,409 +0,0 @@
-/*
-Copyright 2018 New Vector Ltd
-Copyright 2020 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.
-*/
-
-/**
- * Base class for verification methods.
- */
-
-import { MatrixEvent } from "../../models/event.ts";
-import { EventType } from "../../@types/event.ts";
-import { logger } from "../../logger.ts";
-import { DeviceInfo } from "../deviceinfo.ts";
-import { newTimeoutError } from "./Error.ts";
-import { KeysDuringVerification, requestKeysDuringVerification } from "../CrossSigning.ts";
-import { IVerificationChannel } from "./request/Channel.ts";
-import { MatrixClient } from "../../client.ts";
-import { VerificationRequest } from "./request/VerificationRequest.ts";
-import { TypedEventEmitter } from "../../models/typed-event-emitter.ts";
-import {
-    ShowQrCodeCallbacks,
-    ShowSasCallbacks,
-    Verifier,
-    VerifierEvent,
-    VerifierEventHandlerMap,
-} from "../../crypto-api/verification.ts";
-
-const timeoutException = new Error("Verification timed out");
-
-export class SwitchStartEventError extends Error {
-    public constructor(public readonly startEvent: MatrixEvent | null) {
-        super();
-    }
-}
-
-export type KeyVerifier = (keyId: string, device: DeviceInfo, keyInfo: string) => void;
-
-/** @deprecated use VerifierEvent */
-export type VerificationEvent = VerifierEvent;
-/** @deprecated use VerifierEvent */
-export const VerificationEvent = VerifierEvent;
-
-/** @deprecated use VerifierEventHandlerMap */
-export type VerificationEventHandlerMap = {
-    [VerificationEvent.Cancel]: (e: Error | MatrixEvent) => void;
-};
-
-/** @deprecated Avoid referencing this class directly; instead use {@link Crypto.Verifier}. */
-// The type parameters of VerificationBase are no longer used, but we need some placeholders to maintain
-// backwards compatibility with applications that reference the class.
-export class VerificationBase<
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Events extends string = VerifierEvent,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        Arguments = VerifierEventHandlerMap,
-    >
-    extends TypedEventEmitter<VerifierEvent, VerifierEventHandlerMap>
-    implements Verifier
-{
-    private cancelled = false;
-    private _done = false;
-    private promise: Promise<void> | null = null;
-    private transactionTimeoutTimer: ReturnType<typeof setTimeout> | null = null;
-    protected expectedEvent?: string;
-    private resolve?: () => void;
-    private reject?: (e: Error | MatrixEvent) => void;
-    private resolveEvent?: (e: MatrixEvent) => void;
-    private rejectEvent?: (e: Error) => void;
-    private started?: boolean;
-
-    /**
-     * Base class for verification methods.
-     *
-     * <p>Once a verifier object is created, the verification can be started by
-     * calling the verify() method, which will return a promise that will
-     * resolve when the verification is completed, or reject if it could not
-     * complete.</p>
-     *
-     * <p>Subclasses must have a NAME class property.</p>
-     *
-     * @param channel - the verification channel to send verification messages over.
-     * TODO: Channel types
-     *
-     * @param baseApis - base matrix api interface
-     *
-     * @param userId - the user ID that is being verified
-     *
-     * @param deviceId - the device ID that is being verified
-     *
-     * @param startEvent - the m.key.verification.start event that
-     * initiated this verification, if any
-     *
-     * @param request - the key verification request object related to
-     * this verification, if any
-     */
-    public constructor(
-        public readonly channel: IVerificationChannel,
-        public readonly baseApis: MatrixClient,
-        public readonly userId: string,
-        public readonly deviceId: string,
-        public startEvent: MatrixEvent | null,
-        public readonly request: VerificationRequest,
-    ) {
-        super();
-    }
-
-    public get initiatedByMe(): boolean {
-        // if there is no start event yet,
-        // we probably want to send it,
-        // which happens if we initiate
-        if (!this.startEvent) {
-            return true;
-        }
-        const sender = this.startEvent.getSender();
-        const content = this.startEvent.getContent();
-        return sender === this.baseApis.getUserId() && content.from_device === this.baseApis.getDeviceId();
-    }
-
-    public get hasBeenCancelled(): boolean {
-        return this.cancelled;
-    }
-
-    private resetTimer(): void {
-        logger.info("Refreshing/starting the verification transaction timeout timer");
-        if (this.transactionTimeoutTimer !== null) {
-            clearTimeout(this.transactionTimeoutTimer);
-        }
-        this.transactionTimeoutTimer = setTimeout(
-            () => {
-                if (!this._done && !this.cancelled) {
-                    logger.info("Triggering verification timeout");
-                    this.cancel(timeoutException);
-                }
-            },
-            10 * 60 * 1000,
-        ); // 10 minutes
-    }
-
-    private endTimer(): void {
-        if (this.transactionTimeoutTimer !== null) {
-            clearTimeout(this.transactionTimeoutTimer);
-            this.transactionTimeoutTimer = null;
-        }
-    }
-
-    protected send(type: string, uncompletedContent: Record<string, any>): Promise<void> {
-        return this.channel.send(type, uncompletedContent);
-    }
-
-    protected waitForEvent(type: string): Promise<MatrixEvent> {
-        if (this._done) {
-            return Promise.reject(new Error("Verification is already done"));
-        }
-        const existingEvent = this.request.getEventFromOtherParty(type);
-        if (existingEvent) {
-            return Promise.resolve(existingEvent);
-        }
-
-        this.expectedEvent = type;
-        return new Promise((resolve, reject) => {
-            this.resolveEvent = resolve;
-            this.rejectEvent = reject;
-        });
-    }
-
-    public canSwitchStartEvent(event: MatrixEvent): boolean {
-        return false;
-    }
-
-    public switchStartEvent(event: MatrixEvent): void {
-        if (this.canSwitchStartEvent(event)) {
-            logger.log("Verification Base: switching verification start event", { restartingFlow: !!this.rejectEvent });
-            if (this.rejectEvent) {
-                const reject = this.rejectEvent;
-                this.rejectEvent = undefined;
-                reject(new SwitchStartEventError(event));
-            } else {
-                this.startEvent = event;
-            }
-        }
-    }
-
-    public handleEvent(e: MatrixEvent): void {
-        if (this._done) {
-            return;
-        } else if (e.getType() === this.expectedEvent) {
-            // if we receive an expected m.key.verification.done, then just
-            // ignore it, since we don't need to do anything about it
-            if (this.expectedEvent !== EventType.KeyVerificationDone) {
-                this.expectedEvent = undefined;
-                this.rejectEvent = undefined;
-                this.resetTimer();
-                this.resolveEvent?.(e);
-            }
-        } else if (e.getType() === EventType.KeyVerificationCancel) {
-            const reject = this.reject;
-            this.reject = undefined;
-            // there is only promise to reject if verify has been called
-            if (reject) {
-                const content = e.getContent();
-                const { reason, code } = content;
-                reject(new Error(`Other side cancelled verification ` + `because ${reason} (${code})`));
-            }
-        } else if (this.expectedEvent) {
-            // only cancel if there is an event expected.
-            // if there is no event expected, it means verify() wasn't called
-            // and we're just replaying the timeline events when syncing
-            // after a refresh when the events haven't been stored in the cache yet.
-            const exception = new Error(
-                "Unexpected message: expecting " + this.expectedEvent + " but got " + e.getType(),
-            );
-            this.expectedEvent = undefined;
-            if (this.rejectEvent) {
-                const reject = this.rejectEvent;
-                this.rejectEvent = undefined;
-                reject(exception);
-            }
-            this.cancel(exception);
-        }
-    }
-
-    public async done(): Promise<KeysDuringVerification | void> {
-        this.endTimer(); // always kill the activity timer
-        if (!this._done) {
-            this.request.onVerifierFinished();
-            this.resolve?.();
-            return requestKeysDuringVerification(this.baseApis, this.userId, this.deviceId);
-        }
-    }
-
-    public cancel(e: Error | MatrixEvent): void {
-        this.endTimer(); // always kill the activity timer
-        if (!this._done) {
-            this.cancelled = true;
-            this.request.onVerifierCancelled();
-            if (this.userId && this.deviceId) {
-                // send a cancellation to the other user (if it wasn't
-                // cancelled by the other user)
-                if (e === timeoutException) {
-                    const timeoutEvent = newTimeoutError();
-                    this.send(timeoutEvent.getType(), timeoutEvent.getContent());
-                } else if (e instanceof MatrixEvent) {
-                    const sender = e.getSender();
-                    if (sender !== this.userId) {
-                        const content = e.getContent();
-                        if (e.getType() === EventType.KeyVerificationCancel) {
-                            content.code = content.code || "m.unknown";
-                            content.reason = content.reason || content.body || "Unknown reason";
-                            this.send(EventType.KeyVerificationCancel, content);
-                        } else {
-                            this.send(EventType.KeyVerificationCancel, {
-                                code: "m.unknown",
-                                reason: content.body || "Unknown reason",
-                            });
-                        }
-                    }
-                } else {
-                    this.send(EventType.KeyVerificationCancel, {
-                        code: "m.unknown",
-                        reason: e.toString(),
-                    });
-                }
-            }
-            if (this.promise !== null) {
-                // when we cancel without a promise, we end up with a promise
-                // but no reject function. If cancel is called again, we'd error.
-                if (this.reject) this.reject(e);
-            } else {
-                // FIXME: this causes an "Uncaught promise" console message
-                // if nothing ends up chaining this promise.
-                this.promise = Promise.reject(e);
-            }
-            // Also emit a 'cancel' event that the app can listen for to detect cancellation
-            // before calling verify()
-            this.emit(VerificationEvent.Cancel, e);
-        }
-    }
-
-    /**
-     * Begin the key verification
-     *
-     * @returns Promise which resolves when the verification has
-     *     completed.
-     */
-    public verify(): Promise<void> {
-        if (this.promise) return this.promise;
-
-        this.promise = new Promise((resolve, reject) => {
-            this.resolve = (...args): void => {
-                this._done = true;
-                this.endTimer();
-                resolve(...args);
-            };
-            this.reject = (e: Error | MatrixEvent): void => {
-                this._done = true;
-                this.endTimer();
-                reject(e);
-            };
-        });
-        if (this.doVerification && !this.started) {
-            this.started = true;
-            this.resetTimer(); // restart the timeout
-            new Promise<void>((resolve, reject) => {
-                const crossSignId = this.baseApis.crypto!.deviceList.getStoredCrossSigningForUser(this.userId)?.getId();
-                if (crossSignId === this.deviceId) {
-                    reject(new Error("Device ID is the same as the cross-signing ID"));
-                }
-                resolve();
-            })
-                .then(() => this.doVerification!())
-                .then(this.done.bind(this), this.cancel.bind(this));
-        }
-        return this.promise;
-    }
-
-    protected doVerification?: () => Promise<void>;
-
-    protected async verifyKeys(userId: string, keys: Record<string, string>, verifier: KeyVerifier): Promise<void> {
-        // we try to verify all the keys that we're told about, but we might
-        // not know about all of them, so keep track of the keys that we know
-        // about, and ignore the rest
-        const verifiedDevices: [string, string, string][] = [];
-
-        for (const [keyId, keyInfo] of Object.entries(keys)) {
-            const deviceId = keyId.split(":", 2)[1];
-            const device = this.baseApis.getStoredDevice(userId, deviceId);
-            if (device) {
-                verifier(keyId, device, keyInfo);
-                verifiedDevices.push([deviceId, keyId, device.keys[keyId]]);
-            } else {
-                const crossSigningInfo = this.baseApis.crypto!.deviceList.getStoredCrossSigningForUser(userId);
-                if (crossSigningInfo && crossSigningInfo.getId() === deviceId) {
-                    verifier(
-                        keyId,
-                        DeviceInfo.fromStorage(
-                            {
-                                keys: {
-                                    [keyId]: deviceId,
-                                },
-                            },
-                            deviceId,
-                        ),
-                        keyInfo,
-                    );
-                    verifiedDevices.push([deviceId, keyId, deviceId]);
-                } else {
-                    logger.warn(`verification: Could not find device ${deviceId} to verify`);
-                }
-            }
-        }
-
-        // if none of the keys could be verified, then error because the app
-        // should be informed about that
-        if (!verifiedDevices.length) {
-            throw new Error("No devices could be verified");
-        }
-
-        logger.info("Verification completed! Marking devices verified: ", verifiedDevices);
-        // TODO: There should probably be a batch version of this, otherwise it's going
-        // to upload each signature in a separate API call which is silly because the
-        // API supports as many signatures as you like.
-        for (const [deviceId, keyId, key] of verifiedDevices) {
-            await this.baseApis.crypto!.setDeviceVerification(userId, deviceId, true, null, null, { [keyId]: key });
-        }
-
-        // if one of the user's own devices is being marked as verified / unverified,
-        // check the key backup status, since whether or not we use this depends on
-        // whether it has a signature from a verified device
-        if (userId == this.baseApis.credentials.userId) {
-            await this.baseApis.checkKeyBackup();
-        }
-    }
-
-    public get events(): string[] | undefined {
-        return undefined;
-    }
-
-    /**
-     * Get the details for an SAS verification, if one is in progress
-     *
-     * Returns `null`, unless this verifier is for a SAS-based verification and we are waiting for the user to confirm
-     * the SAS matches.
-     */
-    public getShowSasCallbacks(): ShowSasCallbacks | null {
-        return null;
-    }
-
-    /**
-     * Get the details for reciprocating QR code verification, if one is in progress
-     *
-     * Returns `null`, unless this verifier is for reciprocating a QR-code-based verification (ie, the other user has
-     * already scanned our QR code), and we are waiting for the user to confirm.
-     */
-    public getReciprocateQrCodeCallbacks(): ShowQrCodeCallbacks | null {
-        return null;
-    }
-}

package/src/crypto/verification/Error.ts

@@ -1,76 +0,0 @@
-/*
-Copyright 2018 - 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.
-*/
-
-/**
- * Error messages.
- */
-
-import { MatrixEvent } from "../../models/event.ts";
-import { EventType } from "../../@types/event.ts";
-
-export function newVerificationError(code: string, reason: string, extraData?: Record<string, any>): MatrixEvent {
-    const content = Object.assign({}, { code, reason }, extraData);
-    return new MatrixEvent({
-        type: EventType.KeyVerificationCancel,
-        content,
-    });
-}
-
-export function errorFactory(code: string, reason: string): (extraData?: Record<string, any>) => MatrixEvent {
-    return function (extraData?: Record<string, any>) {
-        return newVerificationError(code, reason, extraData);
-    };
-}
-
-/**
- * The verification was cancelled by the user.
- */
-export const newUserCancelledError = errorFactory("m.user", "Cancelled by user");
-
-/**
- * The verification timed out.
- */
-export const newTimeoutError = errorFactory("m.timeout", "Timed out");
-
-/**
- * An unknown method was selected.
- */
-export const newUnknownMethodError = errorFactory("m.unknown_method", "Unknown method");
-
-/**
- * An unexpected message was sent.
- */
-export const newUnexpectedMessageError = errorFactory("m.unexpected_message", "Unexpected message");
-
-/**
- * The key does not match.
- */
-export const newKeyMismatchError = errorFactory("m.key_mismatch", "Key mismatch");
-
-/**
- * An invalid message was sent.
- */
-export const newInvalidMessageError = errorFactory("m.invalid_message", "Invalid message");
-
-export function errorFromEvent(event: MatrixEvent): { code: string; reason: string } {
-    const content = event.getContent();
-    if (content) {
-        const { code, reason } = content;
-        return { code, reason };
-    } else {
-        return { code: "Unknown error", reason: "m.unknown" };
-    }
-}

package/src/crypto/verification/IllegalMethod.ts

@@ -1,50 +0,0 @@
-/*
-Copyright 2020 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.
-*/
-
-/**
- * Verification method that is illegal to have (cannot possibly
- * do verification with this method).
- */
-
-import { VerificationBase as Base, VerificationEvent, VerificationEventHandlerMap } from "./Base.ts";
-import { IVerificationChannel } from "./request/Channel.ts";
-import { MatrixClient } from "../../client.ts";
-import { MatrixEvent } from "../../models/event.ts";
-import { VerificationRequest } from "./request/VerificationRequest.ts";
-
-export class IllegalMethod extends Base<VerificationEvent, VerificationEventHandlerMap> {
-    public static factory(
-        channel: IVerificationChannel,
-        baseApis: MatrixClient,
-        userId: string,
-        deviceId: string,
-        startEvent: MatrixEvent,
-        request: VerificationRequest,
-    ): IllegalMethod {
-        return new IllegalMethod(channel, baseApis, userId, deviceId, startEvent, request);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    public static get NAME(): string {
-        // Typically the name will be something else, but to complete
-        // the contract we offer a default one here.
-        return "org.matrix.illegal_method";
-    }
-
-    protected doVerification = async (): Promise<void> => {
-        throw new Error("Verification is not possible with this method");
-    };
-}