@textrp/briij-js-sdk 41.0.1 → 43.0.0

package/src/version-support.ts

@@ -1,50 +1,50 @@
-/*
-Copyright 2022 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.
-*/
-
-/**
- * A list of the spec versions which the js-sdk is compatible with.
- *
- * In practice, this means: when we connect to a server, it must declare support for one of the versions in this list.
- *
- * Note that it does not *necessarily* mean that the js-sdk has good support for all the features in the listed spec
- * versions; only that we should be able to provide a base level of functionality with a server that offers support for
- * any of the listed versions.
- */
-export const SUPPORTED_MATRIX_VERSIONS = [
-    "v1.1",
-    "v1.2",
-    "v1.3",
-    "v1.4",
-    "v1.5",
-    "v1.6",
-    "v1.7",
-    "v1.8",
-    "v1.9",
-    "v1.10",
-    "v1.11",
-    "v1.12",
-    "v1.13",
-];
-
-/**
- * The oldest Matrix specification version the js-sdk supports.
- */
-export const MINIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[0];
-
-/**
- * The most recent Matrix specification version the js-sdk supports.
- */
-export const MAXIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[SUPPORTED_MATRIX_VERSIONS.length - 1];
+/*
+Copyright 2022 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.
+*/
+
+/**
+ * A list of the spec versions which the js-sdk is compatible with.
+ *
+ * In practice, this means: when we connect to a server, it must declare support for one of the versions in this list.
+ *
+ * Note that it does not *necessarily* mean that the js-sdk has good support for all the features in the listed spec
+ * versions; only that we should be able to provide a base level of functionality with a server that offers support for
+ * any of the listed versions.
+ */
+export const SUPPORTED_MATRIX_VERSIONS = [
+    "v1.1",
+    "v1.2",
+    "v1.3",
+    "v1.4",
+    "v1.5",
+    "v1.6",
+    "v1.7",
+    "v1.8",
+    "v1.9",
+    "v1.10",
+    "v1.11",
+    "v1.12",
+    "v1.13",
+];
+
+/**
+ * The oldest Matrix specification version the js-sdk supports.
+ */
+export const MINIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[0];
+
+/**
+ * The most recent Matrix specification version the js-sdk supports.
+ */
+export const MAXIMUM_MATRIX_VERSION = SUPPORTED_MATRIX_VERSIONS[SUPPORTED_MATRIX_VERSIONS.length - 1];

package/src/wallet-recovery.ts

@@ -0,0 +1,252 @@
+/*
+Copyright 2026 TextRP
+
+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 { type WalletE2eeRecoveryEnvelope, type WalletRecoveryWrap } from "./@types/auth.ts";
+
+const ENVELOPE_VERSION = 1;
+const KEY_BYTES = 32;
+const NONCE_BYTES = 12;
+const SALT_BYTES = 16;
+const PASSWORD_KDF_ITERATIONS = 210_000;
+
+export interface CreateDualWrapEnvelopeParams {
+    chainId: string;
+    accountId: string;
+    backupPassword: string;
+    walletWrapKey: Uint8Array;
+    createdAtMs?: number;
+    keyId?: string;
+    recoveryKey?: Uint8Array;
+}
+
+export interface UnwrapWithWalletParams {
+    envelope: WalletE2eeRecoveryEnvelope;
+    walletWrapKey: Uint8Array;
+}
+
+export interface UnwrapWithPasswordParams {
+    envelope: WalletE2eeRecoveryEnvelope;
+    backupPassword: string;
+}
+
+function assert(condition: boolean, message: string): asserts condition {
+    if (!condition) throw new Error(message);
+}
+
+function toBase64(bytes: Uint8Array): string {
+    if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+    let binary = "";
+    bytes.forEach((b) => (binary += String.fromCodePoint(b)));
+    return btoa(binary);
+}
+
+function fromBase64(value: string): Uint8Array {
+    if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "base64"));
+    const binary = atob(value);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) out[i] = binary.codePointAt(i)!;
+    return out;
+}
+
+function toUtf8(value: string): Uint8Array {
+    return new TextEncoder().encode(value);
+}
+
+function toArrayBuffer(value: Uint8Array): ArrayBuffer {
+    return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength) as ArrayBuffer;
+}
+
+function randomBytes(len: number): Uint8Array {
+    const out = new Uint8Array(len);
+    globalThis.crypto.getRandomValues(out);
+    return out;
+}
+
+async function importAesGcmKey(key: Uint8Array): Promise<CryptoKey> {
+    return await globalThis.crypto.subtle.importKey(
+        "raw",
+        toArrayBuffer(key),
+        { name: "AES-GCM" },
+        false,
+        ["encrypt", "decrypt"],
+    );
+}
+
+async function encryptWrap(
+    plaintext: Uint8Array,
+    {
+        key,
+        aad,
+        kdf,
+        params,
+    }: {
+        key: Uint8Array;
+        aad: Uint8Array;
+        kdf: string;
+        params?: Record<string, unknown>;
+    },
+): Promise<WalletRecoveryWrap> {
+    assert(key.length >= KEY_BYTES, "wallet recovery key must be at least 32 bytes");
+    const salt = randomBytes(SALT_BYTES);
+    const nonce = randomBytes(NONCE_BYTES);
+    const cryptoKey = await importAesGcmKey(key.slice(0, KEY_BYTES));
+    const ciphertext = await globalThis.crypto.subtle.encrypt(
+        {
+            name: "AES-GCM",
+            iv: toArrayBuffer(nonce),
+            additionalData: toArrayBuffer(aad),
+            tagLength: 128,
+        },
+        cryptoKey,
+        toArrayBuffer(plaintext),
+    );
+    return {
+        alg: "aes-256-gcm",
+        kdf,
+        salt: toBase64(salt),
+        nonce: toBase64(nonce),
+        ciphertext: toBase64(new Uint8Array(ciphertext)),
+        aad: toBase64(aad),
+        params,
+    };
+}
+
+async function decryptWrap(wrap: WalletRecoveryWrap, key: Uint8Array): Promise<Uint8Array> {
+    const nonce = fromBase64(wrap.nonce);
+    const aad = wrap.aad ? fromBase64(wrap.aad) : new Uint8Array();
+    const ciphertext = fromBase64(wrap.ciphertext);
+    const cryptoKey = await importAesGcmKey(key.slice(0, KEY_BYTES));
+    const plaintext = await globalThis.crypto.subtle.decrypt(
+        {
+            name: "AES-GCM",
+            iv: toArrayBuffer(nonce),
+            additionalData: toArrayBuffer(aad),
+            tagLength: 128,
+        },
+        cryptoKey,
+        toArrayBuffer(ciphertext),
+    );
+    return new Uint8Array(plaintext);
+}
+
+async function derivePasswordWrapKey(password: string, salt: Uint8Array): Promise<Uint8Array> {
+    const keyMaterial = await globalThis.crypto.subtle.importKey("raw", toArrayBuffer(toUtf8(password)), "PBKDF2", false, [
+        "deriveBits",
+    ]);
+    const bits = await globalThis.crypto.subtle.deriveBits(
+        {
+            name: "PBKDF2",
+            hash: "SHA-256",
+            salt: toArrayBuffer(salt),
+            iterations: PASSWORD_KDF_ITERATIONS,
+        },
+        keyMaterial,
+        KEY_BYTES * 8,
+    );
+    return new Uint8Array(bits);
+}
+
+export async function deriveWalletWrapKeyFromSecret(
+    walletSecret: string,
+    chainId: string,
+    accountId: string,
+    homeserver: string,
+): Promise<Uint8Array> {
+    const context = `briij-wallet-auth-wrap-v1:${homeserver}:${chainId}:${accountId}`;
+    const digest = await globalThis.crypto.subtle.digest(
+        "SHA-256",
+        toArrayBuffer(toUtf8(`${context}:${walletSecret}`)),
+    );
+    return new Uint8Array(digest);
+}
+
+export function validateRecoveryEnvelopeShape(
+    value: unknown,
+): asserts value is WalletE2eeRecoveryEnvelope {
+    assert(!!value && typeof value === "object", "recovery envelope must be an object");
+    const envelope = value as WalletE2eeRecoveryEnvelope;
+    assert(typeof envelope.envelope_version === "number", "envelope_version must be a number");
+    assert(typeof envelope.chain_id === "string" && envelope.chain_id.length > 0, "chain_id is required");
+    assert(typeof envelope.account_id === "string" && envelope.account_id.length > 0, "account_id is required");
+    assert(typeof envelope.created_at_ms === "number", "created_at_ms must be a number");
+    assert(typeof envelope.key_id === "string" && envelope.key_id.length > 0, "key_id is required");
+    assert(!!envelope.wallet_wrap && typeof envelope.wallet_wrap === "object", "wallet_wrap is required");
+    assert(!!envelope.password_wrap && typeof envelope.password_wrap === "object", "password_wrap is required");
+    for (const wrap of [envelope.wallet_wrap, envelope.password_wrap]) {
+        assert(typeof wrap.alg === "string" && wrap.alg.length > 0, "wrap.alg is required");
+        assert(typeof wrap.kdf === "string" && wrap.kdf.length > 0, "wrap.kdf is required");
+        assert(typeof wrap.salt === "string" && wrap.salt.length > 0, "wrap.salt is required");
+        assert(typeof wrap.nonce === "string" && wrap.nonce.length > 0, "wrap.nonce is required");
+        assert(typeof wrap.ciphertext === "string" && wrap.ciphertext.length > 0, "wrap.ciphertext is required");
+    }
+}
+
+export async function createDualWrapEnvelope(params: CreateDualWrapEnvelopeParams): Promise<WalletE2eeRecoveryEnvelope> {
+    assert(params.chainId.length > 0, "chainId is required");
+    assert(params.accountId.length > 0, "accountId is required");
+    assert(params.backupPassword.length > 0, "backupPassword is required");
+    assert(params.walletWrapKey.length >= KEY_BYTES, "walletWrapKey must be at least 32 bytes");
+
+    const createdAtMs = params.createdAtMs ?? Date.now();
+    const keyId = params.keyId ?? `k-${toBase64(randomBytes(8)).replace(/=+$/g, "")}`;
+    const recoveryKey = params.recoveryKey ?? randomBytes(KEY_BYTES);
+    assert(recoveryKey.length === KEY_BYTES, "recoveryKey must be 32 bytes");
+
+    const aad = toUtf8(`briij-recovery-envelope-v1:${params.chainId}:${params.accountId}:${keyId}:${createdAtMs}`);
+    const walletWrap = await encryptWrap(recoveryKey, {
+        key: params.walletWrapKey,
+        aad,
+        kdf: "sha256-context-v1",
+    });
+
+    const passwordSalt = randomBytes(SALT_BYTES);
+    const passwordWrapKey = await derivePasswordWrapKey(params.backupPassword, passwordSalt);
+    const passwordWrap = await encryptWrap(recoveryKey, {
+        key: passwordWrapKey,
+        aad,
+        kdf: "pbkdf2-sha256-v1",
+        params: {
+            iterations: PASSWORD_KDF_ITERATIONS,
+            hash: "SHA-256",
+        },
+    });
+    passwordWrap.salt = toBase64(passwordSalt);
+
+    return {
+        envelope_version: ENVELOPE_VERSION,
+        chain_id: params.chainId,
+        account_id: params.accountId,
+        created_at_ms: createdAtMs,
+        key_id: keyId,
+        wallet_wrap: walletWrap,
+        password_wrap: passwordWrap,
+    };
+}
+
+export async function unwrapWithWallet({ envelope, walletWrapKey }: UnwrapWithWalletParams): Promise<Uint8Array> {
+    validateRecoveryEnvelopeShape(envelope);
+    return await decryptWrap(envelope.wallet_wrap, walletWrapKey);
+}
+
+export async function unwrapWithPassword({
+    envelope,
+    backupPassword,
+}: UnwrapWithPasswordParams): Promise<Uint8Array> {
+    validateRecoveryEnvelopeShape(envelope);
+    const passwordSalt = fromBase64(envelope.password_wrap.salt);
+    const passwordWrapKey = await derivePasswordWrapKey(backupPassword, passwordSalt);
+    return await decryptWrap(envelope.password_wrap, passwordWrapKey);
+}

package/src/webrtc/audioContext.ts

@@ -1,44 +1,44 @@
-/*
-Copyright 2022 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.
-*/
-
-let audioContext: AudioContext | null = null;
-let refCount = 0;
-
-/**
- * Acquires a reference to the shared AudioContext.
- * It's highly recommended to reuse this AudioContext rather than creating your
- * own, because multiple AudioContexts can be problematic in some browsers.
- * Make sure to call releaseContext when you're done using it.
- * @returns The shared AudioContext
- */
-export const acquireContext = (): AudioContext => {
-    if (audioContext === null) audioContext = new AudioContext();
-    refCount++;
-    return audioContext;
-};
-
-/**
- * Signals that one of the references to the shared AudioContext has been
- * released, allowing the context and associated hardware resources to be
- * cleaned up if nothing else is using it.
- */
-export const releaseContext = (): void => {
-    refCount--;
-    if (refCount === 0) {
-        audioContext?.close();
-        audioContext = null;
-    }
-};
+/*
+Copyright 2022 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.
+*/
+
+let audioContext: AudioContext | null = null;
+let refCount = 0;
+
+/**
+ * Acquires a reference to the shared AudioContext.
+ * It's highly recommended to reuse this AudioContext rather than creating your
+ * own, because multiple AudioContexts can be problematic in some browsers.
+ * Make sure to call releaseContext when you're done using it.
+ * @returns The shared AudioContext
+ */
+export const acquireContext = (): AudioContext => {
+    if (audioContext === null) audioContext = new AudioContext();
+    refCount++;
+    return audioContext;
+};
+
+/**
+ * Signals that one of the references to the shared AudioContext has been
+ * released, allowing the context and associated hardware resources to be
+ * cleaned up if nothing else is using it.
+ */
+export const releaseContext = (): void => {
+    refCount--;
+    if (refCount === 0) {
+        audioContext?.close();
+        audioContext = null;
+    }
+};

package/src/webrtc/callEventTypes.ts

@@ -1,101 +1,101 @@
-// allow non-camelcase as these are events type that go onto the wire
-/* eslint-disable camelcase */
-
-import { type CallErrorCode } from "./call.ts";
-import { NamespacedValue } from "../NamespacedValue.ts";
-
-export const SDPStreamMetadataKey = new NamespacedValue(
-    "sdp_stream_metadata",
-    "org.matrix.msc3077.sdp_stream_metadata",
-);
-
-export enum SDPStreamMetadataPurpose {
-    Usermedia = "m.usermedia",
-    Screenshare = "m.screenshare",
-}
-
-export interface SDPStreamMetadataObject {
-    purpose: SDPStreamMetadataPurpose;
-    audio_muted: boolean;
-    video_muted: boolean;
-}
-
-export interface SDPStreamMetadata {
-    [key: string]: SDPStreamMetadataObject;
-}
-
-export interface CallCapabilities {
-    "m.call.transferee": boolean;
-    "m.call.dtmf": boolean;
-}
-
-export interface CallReplacesTarget {
-    id: string;
-    display_name: string;
-    avatar_url: string;
-}
-
-export interface MCallBase {
-    call_id: string;
-    conf_id?: string;
-    version: string | number;
-    party_id?: string;
-    sender_session_id?: string;
-    dest_session_id?: string;
-}
-
-type Description = Pick<RTCSessionDescription, "type" | "sdp">;
-
-export interface MCallAnswer extends MCallBase {
-    "answer": Description;
-    "capabilities"?: CallCapabilities;
-    "sdp_stream_metadata"?: SDPStreamMetadata;
-    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
-}
-
-export interface MCallSelectAnswer extends MCallBase {
-    selected_party_id: string;
-}
-
-export interface MCallInviteNegotiate extends MCallBase {
-    "offer": Description;
-    "description": Description;
-    "lifetime": number;
-    "capabilities"?: CallCapabilities;
-    "invitee"?: string;
-    "sender_session_id"?: string;
-    "dest_session_id"?: string;
-    "sdp_stream_metadata"?: SDPStreamMetadata;
-    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
-}
-
-export interface MCallSDPStreamMetadataChanged extends MCallBase {
-    "sdp_stream_metadata"?: SDPStreamMetadata;
-    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
-}
-
-export interface MCallReplacesEvent extends MCallBase {
-    replacement_id: string;
-    target_user: CallReplacesTarget;
-    create_call: string;
-    await_call: string;
-    target_room: string;
-}
-
-export interface MCAllAssertedIdentity extends MCallBase {
-    asserted_identity: {
-        id: string;
-        display_name: string;
-        avatar_url: string;
-    };
-}
-
-export interface MCallCandidates extends MCallBase {
-    candidates: Omit<RTCIceCandidateInit, "usernameFragment">[];
-}
-
-export interface MCallHangupReject extends MCallBase {
-    reason?: CallErrorCode;
-}
-
-/* eslint-enable camelcase */
+// allow non-camelcase as these are events type that go onto the wire
+/* eslint-disable camelcase */
+
+import { type CallErrorCode } from "./call.ts";
+import { NamespacedValue } from "../NamespacedValue.ts";
+
+export const SDPStreamMetadataKey = new NamespacedValue(
+    "sdp_stream_metadata",
+    "org.matrix.msc3077.sdp_stream_metadata",
+);
+
+export enum SDPStreamMetadataPurpose {
+    Usermedia = "m.usermedia",
+    Screenshare = "m.screenshare",
+}
+
+export interface SDPStreamMetadataObject {
+    purpose: SDPStreamMetadataPurpose;
+    audio_muted: boolean;
+    video_muted: boolean;
+}
+
+export interface SDPStreamMetadata {
+    [key: string]: SDPStreamMetadataObject;
+}
+
+export interface CallCapabilities {
+    "m.call.transferee": boolean;
+    "m.call.dtmf": boolean;
+}
+
+export interface CallReplacesTarget {
+    id: string;
+    display_name: string;
+    avatar_url: string;
+}
+
+export interface MCallBase {
+    call_id: string;
+    conf_id?: string;
+    version: string | number;
+    party_id?: string;
+    sender_session_id?: string;
+    dest_session_id?: string;
+}
+
+type Description = Pick<RTCSessionDescription, "type" | "sdp">;
+
+export interface MCallAnswer extends MCallBase {
+    "answer": Description;
+    "capabilities"?: CallCapabilities;
+    "sdp_stream_metadata"?: SDPStreamMetadata;
+    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
+}
+
+export interface MCallSelectAnswer extends MCallBase {
+    selected_party_id: string;
+}
+
+export interface MCallInviteNegotiate extends MCallBase {
+    "offer": Description;
+    "description": Description;
+    "lifetime": number;
+    "capabilities"?: CallCapabilities;
+    "invitee"?: string;
+    "sender_session_id"?: string;
+    "dest_session_id"?: string;
+    "sdp_stream_metadata"?: SDPStreamMetadata;
+    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
+}
+
+export interface MCallSDPStreamMetadataChanged extends MCallBase {
+    "sdp_stream_metadata"?: SDPStreamMetadata;
+    "org.matrix.msc3077.sdp_stream_metadata"?: SDPStreamMetadata;
+}
+
+export interface MCallReplacesEvent extends MCallBase {
+    replacement_id: string;
+    target_user: CallReplacesTarget;
+    create_call: string;
+    await_call: string;
+    target_room: string;
+}
+
+export interface MCAllAssertedIdentity extends MCallBase {
+    asserted_identity: {
+        id: string;
+        display_name: string;
+        avatar_url: string;
+    };
+}
+
+export interface MCallCandidates extends MCallBase {
+    candidates: Omit<RTCIceCandidateInit, "usernameFragment">[];
+}
+
+export interface MCallHangupReject extends MCallBase {
+    reason?: CallErrorCode;
+}
+
+/* eslint-enable camelcase */