@matter/general 0.15.0-alpha.0-20250612-ddd428561 → 0.15.0-alpha.0-20250614-b9829e223

package/src/crypto/MockCrypto.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2022-2025 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { ImplementationError } from "#MatterError.js";
+import { Crypto, ec } from "./Crypto.js";
+import { CurveType, Key, KeyType, PrivateKey } from "./Key.js";
+import { StandardCrypto } from "./StandardCrypto.js";
+
+/**
+ * WARNING: ONLY FOR USE IN PROTECTED TESTING ENVIRONMENTS WHERE SECURITY IS NOT A CONCERN
+ *
+ * A {@link Crypto} with sources of entropy replaced to produce stable values based on an input index.
+ *
+ * This is useful in testing environments where Matter logic is difficult to test with true entropy.
+ *
+ * Depending on implementation some methods may need further mocking to remove entropy entirely.  Mocking is sufficient
+ * for current testing purposes.
+ */
+export interface MockCrypto extends Crypto {
+    /**
+     * The index of the random space.  May be modified to adjust computations going forward.
+     */
+    index: number;
+}
+
+export function MockCrypto(index: number = 0x80, implementation: new () => Crypto = StandardCrypto) {
+    if (index < 0 || index > 255) {
+        throw new ImplementationError(`Index for stable crypto must be 0-255`);
+    }
+
+    const crypto = new implementation();
+
+    // Create random data consisting of index repeated
+    crypto.randomBytes = function getRandomDataNONENTROPIC(length) {
+        const result = new Uint8Array(length);
+        result.fill(index);
+        return result;
+    };
+
+    // Ensure EC key generation uses our own "entropy" source rather than the platform's
+    crypto.createKeyPair = function getRandomDataNONENTROPIC() {
+        const privateBits = ec.mapHashToField(new Uint8Array(crypto.randomBytes(48)), ec.p256.CURVE.n);
+        return Key({
+            kty: KeyType.EC,
+            crv: CurveType.p256,
+            privateBits,
+        }) as PrivateKey;
+    };
+
+    Object.defineProperty(crypto, "index", {
+        get() {
+            return index;
+        },
+
+        set(newIndex: number) {
+            index = newIndex % 256;
+        },
+    });
+
+    return crypto as MockCrypto;
+}

package/src/crypto/Spake2p.ts

@@ -29,39 +29,50 @@ export interface PbkdfParameters {
 }
 
 export class Spake2p {
-    static async computeW0W1({ iterations, salt }: PbkdfParameters, pin: number) {
+    readonly #crypto: Crypto;
+    readonly #context: Uint8Array;
+    readonly #random: bigint;
+    readonly #w0: bigint;
+
+    static async computeW0W1(crypto: Crypto, { iterations, salt }: PbkdfParameters, pin: number) {
         const pinWriter = new DataWriter(Endian.Little);
         pinWriter.writeUInt32(pin);
-        const ws = await Crypto.createPbkdf2Key(pinWriter.toByteArray(), salt, iterations, CRYPTO_W_SIZE_BYTES * 2);
+        const ws = await crypto.createPbkdf2Key(pinWriter.toByteArray(), salt, iterations, CRYPTO_W_SIZE_BYTES * 2);
         const w0 = mod(bytesToNumberBE(ws.slice(0, 40)), P256_CURVE.n);
         const w1 = mod(bytesToNumberBE(ws.slice(40, 80)), P256_CURVE.n);
         return { w0, w1 };
     }
 
-    static async computeW0L(pbkdfParameters: PbkdfParameters, pin: number) {
-        const { w0, w1 } = await this.computeW0W1(pbkdfParameters, pin);
+    static async computeW0L(crypto: Crypto, pbkdfParameters: PbkdfParameters, pin: number) {
+        const { w0, w1 } = await this.computeW0W1(crypto, pbkdfParameters, pin);
         const L = ProjectivePoint.BASE.multiply(w1).toRawBytes(false);
         return { w0, L };
     }
 
-    static create(context: Uint8Array, w0: bigint) {
-        const random = Crypto.getRandomBigInt(32, P256_CURVE.Fp.ORDER);
-        return new Spake2p(context, random, w0);
+    static create(crypto: Crypto, context: Uint8Array, w0: bigint) {
+        const random = crypto.randomBigInt(32, P256_CURVE.Fp.ORDER);
+        return new Spake2p(crypto, context, random, w0);
     }
 
     constructor(
-        private readonly context: Uint8Array,
-        private readonly random: bigint,
-        private readonly w0: bigint,
-    ) {}
+        crypto: Crypto,
+        readonly context: Uint8Array,
+        readonly random: bigint,
+        readonly w0: bigint,
+    ) {
+        this.#crypto = crypto;
+        this.#context = context;
+        this.#random = random;
+        this.#w0 = w0;
+    }
 
     computeX(): Uint8Array {
-        const X = ProjectivePoint.BASE.multiply(this.random).add(M.multiply(this.w0));
+        const X = ProjectivePoint.BASE.multiply(this.#random).add(M.multiply(this.#w0));
         return X.toRawBytes(false);
     }
 
     computeY(): Uint8Array {
-        const Y = ProjectivePoint.BASE.multiply(this.random).add(N.multiply(this.w0));
+        const Y = ProjectivePoint.BASE.multiply(this.#random).add(N.multiply(this.#w0));
         return Y.toRawBytes(false);
     }
 
@@ -72,8 +83,8 @@ export class Spake2p {
         } catch (error) {
             throw new InternalError(`Y is not on the curve: ${(error as any).message}`);
         }
-        const yNwo = YPoint.add(N.multiply(this.w0).negate());
-        const Z = yNwo.multiply(this.random);
+        const yNwo = YPoint.add(N.multiply(this.#w0).negate());
+        const Z = yNwo.multiply(this.#random);
         const V = yNwo.multiply(w1);
         return this.computeSecretAndVerifiers(X, Y, Z.toRawBytes(false), V.toRawBytes(false));
     }
@@ -86,8 +97,8 @@ export class Spake2p {
         } catch (error) {
             throw new InternalError(`X is not on the curve: ${(error as any).message}`);
         }
-        const Z = XPoint.add(M.multiply(this.w0).negate()).multiply(this.random);
-        const V = LPoint.multiply(this.random);
+        const Z = XPoint.add(M.multiply(this.#w0).negate()).multiply(this.#random);
+        const V = LPoint.multiply(this.#random);
         return this.computeSecretAndVerifiers(X, Y, Z.toRawBytes(false), V.toRawBytes(false));
     }
 
@@ -96,19 +107,19 @@ export class Spake2p {
         const Ka = TT_HASH.slice(0, 16);
         const Ke = TT_HASH.slice(16, 32);
 
-        const KcAB = await Crypto.createHkdfKey(Ka, new Uint8Array(0), Bytes.fromString("ConfirmationKeys"), 32);
+        const KcAB = await this.#crypto.createHkdfKey(Ka, new Uint8Array(0), Bytes.fromString("ConfirmationKeys"), 32);
         const KcA = KcAB.slice(0, 16);
         const KcB = KcAB.slice(16, 32);
 
-        const hAY = await Crypto.signHmac(KcA, Y);
-        const hBX = await Crypto.signHmac(KcB, X);
+        const hAY = await this.#crypto.signHmac(KcA, Y);
+        const hBX = await this.#crypto.signHmac(KcB, X);
 
         return { Ke, hAY, hBX };
     }
 
     private computeTranscriptHash(X: Uint8Array, Y: Uint8Array, Z: Uint8Array, V: Uint8Array) {
         const TTwriter = new DataWriter(Endian.Little);
-        this.addToContext(TTwriter, this.context);
+        this.addToContext(TTwriter, this.#context);
         this.addToContext(TTwriter, Bytes.fromString(""));
         this.addToContext(TTwriter, Bytes.fromString(""));
         this.addToContext(TTwriter, M.toRawBytes(false));
@@ -117,8 +128,8 @@ export class Spake2p {
         this.addToContext(TTwriter, Y);
         this.addToContext(TTwriter, Z);
         this.addToContext(TTwriter, V);
-        this.addToContext(TTwriter, numberToBytesBE(this.w0, 32));
-        return Crypto.computeSha256(TTwriter.toByteArray());
+        this.addToContext(TTwriter, numberToBytesBE(this.#w0, 32));
+        return this.#crypto.computeSha256(TTwriter.toByteArray());
     }
 
     private addToContext(TTwriter: DataWriter<Endian.Little>, data: Uint8Array) {

package/src/crypto/StandardCrypto.ts

@@ -6,7 +6,7 @@
  */
 
 import { DerBigUint, DerCodec, DerError } from "#codec/DerCodec.js";
-import { Boot } from "#util/Boot.js";
+import { Environment } from "#environment/Environment.js";
 import { Bytes } from "#util/Bytes.js";
 import { Ccm } from "./aes/Ccm.js";
 import { Crypto, CRYPTO_SYMMETRIC_KEY_LENGTH, CryptoDsaEncoding } from "./Crypto.js";
@@ -30,14 +30,14 @@ const SIGNATURE_ALGORITHM = <EcdsaParams>{
  * Web Crypto doesn't support AES-CCM required by Matter so fall back to a JS implementation for that.  See relevant
  * warnings in the "aes" subdirectory.
  */
-export class StandardCrypto implements Crypto {
+export class StandardCrypto extends Crypto {
     implementationName = "JS";
 
     static provider() {
         return new StandardCrypto();
     }
 
-    getRandomData(length: number): Uint8Array {
+    randomBytes(length: number): Uint8Array {
         const result = new Uint8Array(length);
         crypto.getRandomValues(result);
         return result;
@@ -221,13 +221,6 @@ export class StandardCrypto implements Crypto {
     }
 }
 
-// Only install if VM supports Web Crypto
-if ((globalThis.crypto as any)?.subtle?.[Symbol.toStringTag] === "SubtleCrypto") {
-    Boot.init(() => {
-        Crypto.provider = StandardCrypto.provider;
-    });
-}
-
 function importKey(
     format: "jwk",
     keyData: JsonWebKey,
@@ -250,3 +243,6 @@ async function importKey(...params: unknown[]) {
         throw new KeyInputError("Invalid key", { cause });
     }
 }
+
+// Unconditionally add to Environment as it has not been exported yet so there can be no other implementation present
+Environment.default.set(Crypto, new StandardCrypto());

package/src/crypto/index.ts

@@ -8,6 +8,6 @@ export * from "./Crypto.js";
 export * from "./CryptoConstants.js";
 export * from "./CryptoError.js";
 export * from "./Key.js";
-export * from "./nonentropic.js";
+export * from "./MockCrypto.js";
 export * from "./Spake2p.js";
 export * from "./StandardCrypto.js";

package/src/util/Bytes.ts

@@ -89,4 +89,26 @@ export namespace Bytes {
         });
         return result;
     }
+
+    export function asBigInt(bytes: Uint8Array) {
+        const view = new DataView(bytes.buffer);
+        let result = 0n;
+        for (let i = 0; i < bytes.length; ) {
+            const remaining = bytes.length - i;
+            if (remaining >= 8) {
+                result = (result << 64n) + view.getBigUint64(i);
+                i += 8;
+            } else if (remaining >= 4) {
+                result = (result << 32n) + BigInt(view.getUint32(i));
+                i += 4;
+            } else if (remaining >= 2) {
+                result = (result << 16n) + BigInt(view.getUint16(i));
+                i += 2;
+            } else {
+                result = (result << 8n) + BigInt(view.getUint8(i));
+                i++;
+            }
+        }
+        return result;
+    }
 }

package/dist/cjs/crypto/nonentropic.d.ts

@@ -1,16 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * WARNING: ONLY FOR USE IN PROTECTED TESTING ENVIRONMENTS WHERE SECURITY IS NOT A CONCERN
- *
- * Execute {@link actor} with sources of entropy replaced to produce stable values based on an input index.
- *
- * This is useful in testing environments where Matter logic is difficult to test with true entropy.
- *
- * I believe there are some crypto functions that are not fully mocked here but this covers current test cases.
- */
-export declare function nonentropic<T>(index: number, actor: () => T): T;
-//# sourceMappingURL=nonentropic.d.ts.map

package/dist/cjs/crypto/nonentropic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nonentropic.d.ts","sourceRoot":"","sources":["../../../src/crypto/nonentropic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CA4C/D"}

package/dist/cjs/crypto/nonentropic.js

@@ -1,70 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var nonentropic_exports = {};
-__export(nonentropic_exports, {
-  nonentropic: () => nonentropic
-});
-module.exports = __toCommonJS(nonentropic_exports);
-var import_MatterError = require("#MatterError.js");
-var import_Promises = require("#util/Promises.js");
-var import_Crypto = require("./Crypto.js");
-var import_Key = require("./Key.js");
-/**
- * @license
- * Copyright 2022-2025 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-function nonentropic(index, actor) {
-  if (index < 0 || index > 255) {
-    throw new import_MatterError.ImplementationError(`Index for stable crypto must be 0-255`);
-  }
-  const crypto = import_Crypto.Crypto.default;
-  const { getRandomData, createKeyPair } = crypto;
-  let isAsync = false;
-  try {
-    crypto.getRandomData = function getRandomDataNONENTROPIC(length) {
-      const result2 = new Uint8Array(length);
-      result2.fill(index);
-      return result2;
-    };
-    crypto.createKeyPair = function getRandomDataNONENTROPIC() {
-      const privateBits = import_Crypto.ec.mapHashToField(crypto.getRandomData(48), import_Crypto.ec.p256.CURVE.n);
-      return (0, import_Key.Key)({
-        kty: import_Key.KeyType.EC,
-        crv: import_Key.CurveType.p256,
-        privateBits
-      });
-    };
-    let result = actor();
-    if (import_Promises.MaybePromise.is(result)) {
-      isAsync = true;
-      result = Promise.resolve(result).finally(revert);
-    }
-    return result;
-  } finally {
-    if (!isAsync) {
-      revert();
-    }
-  }
-  function revert() {
-    crypto.getRandomData = getRandomData;
-    crypto.createKeyPair = createKeyPair;
-  }
-}
-//# sourceMappingURL=nonentropic.js.map

package/dist/cjs/crypto/nonentropic.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/crypto/nonentropic.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,yBAAoC;AACpC,sBAA6B;AAC7B,oBAA2B;AAC3B,iBAAoD;AATpD;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,YAAe,OAAe,OAAmB;AAC7D,MAAI,QAAQ,KAAK,QAAQ,KAAK;AAC1B,UAAM,IAAI,uCAAoB,uCAAuC;AAAA,EACzE;AAEA,QAAM,SAAS,qBAAO;AACtB,QAAM,EAAE,eAAe,cAAc,IAAI;AACzC,MAAI,UAAU;AAEd,MAAI;AAEA,WAAO,gBAAgB,SAAS,yBAAyB,QAAQ;AAC7D,YAAMA,UAAS,IAAI,WAAW,MAAM;AACpC,MAAAA,QAAO,KAAK,KAAK;AACjB,aAAOA;AAAA,IACX;AAGA,WAAO,gBAAgB,SAAS,2BAA2B;AACvD,YAAM,cAAc,iBAAG,eAAe,OAAO,cAAc,EAAE,GAAG,iBAAG,KAAK,MAAM,CAAC;AAC/E,iBAAO,gBAAI;AAAA,QACP,KAAK,mBAAQ;AAAA,QACb,KAAK,qBAAU;AAAA,QACf;AAAA,MACJ,CAAC;AAAA,IACL;AAEA,QAAI,SAAS,MAAM;AACnB,QAAI,6BAAa,GAAG,MAAM,GAAG;AACzB,gBAAU;AACV,eAAS,QAAQ,QAAQ,MAAM,EAAE,QAAQ,MAAM;AAAA,IACnD;AAEA,WAAO;AAAA,EACX,UAAE;AACE,QAAI,CAAC,SAAS;AACV,aAAO;AAAA,IACX;AAAA,EACJ;AAEA,WAAS,SAAS;AACd,WAAO,gBAAgB;AACvB,WAAO,gBAAgB;AAAA,EAC3B;AACJ;",
-  "names": ["result"]
-}

package/dist/esm/crypto/nonentropic.d.ts

@@ -1,16 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * WARNING: ONLY FOR USE IN PROTECTED TESTING ENVIRONMENTS WHERE SECURITY IS NOT A CONCERN
- *
- * Execute {@link actor} with sources of entropy replaced to produce stable values based on an input index.
- *
- * This is useful in testing environments where Matter logic is difficult to test with true entropy.
- *
- * I believe there are some crypto functions that are not fully mocked here but this covers current test cases.
- */
-export declare function nonentropic<T>(index: number, actor: () => T): T;
-//# sourceMappingURL=nonentropic.d.ts.map

package/dist/esm/crypto/nonentropic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nonentropic.d.ts","sourceRoot":"","sources":["../../../src/crypto/nonentropic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CA4C/D"}

package/dist/esm/crypto/nonentropic.js

@@ -1,50 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-import { ImplementationError } from "#MatterError.js";
-import { MaybePromise } from "#util/Promises.js";
-import { Crypto, ec } from "./Crypto.js";
-import { CurveType, Key, KeyType } from "./Key.js";
-function nonentropic(index, actor) {
-  if (index < 0 || index > 255) {
-    throw new ImplementationError(`Index for stable crypto must be 0-255`);
-  }
-  const crypto = Crypto.default;
-  const { getRandomData, createKeyPair } = crypto;
-  let isAsync = false;
-  try {
-    crypto.getRandomData = function getRandomDataNONENTROPIC(length) {
-      const result2 = new Uint8Array(length);
-      result2.fill(index);
-      return result2;
-    };
-    crypto.createKeyPair = function getRandomDataNONENTROPIC() {
-      const privateBits = ec.mapHashToField(crypto.getRandomData(48), ec.p256.CURVE.n);
-      return Key({
-        kty: KeyType.EC,
-        crv: CurveType.p256,
-        privateBits
-      });
-    };
-    let result = actor();
-    if (MaybePromise.is(result)) {
-      isAsync = true;
-      result = Promise.resolve(result).finally(revert);
-    }
-    return result;
-  } finally {
-    if (!isAsync) {
-      revert();
-    }
-  }
-  function revert() {
-    crypto.getRandomData = getRandomData;
-    crypto.createKeyPair = createKeyPair;
-  }
-}
-export {
-  nonentropic
-};
-//# sourceMappingURL=nonentropic.js.map

package/dist/esm/crypto/nonentropic.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/crypto/nonentropic.ts"],
-  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,2BAA2B;AACpC,SAAS,oBAAoB;AAC7B,SAAS,QAAQ,UAAU;AAC3B,SAAS,WAAW,KAAK,eAA2B;AAW7C,SAAS,YAAe,OAAe,OAAmB;AAC7D,MAAI,QAAQ,KAAK,QAAQ,KAAK;AAC1B,UAAM,IAAI,oBAAoB,uCAAuC;AAAA,EACzE;AAEA,QAAM,SAAS,OAAO;AACtB,QAAM,EAAE,eAAe,cAAc,IAAI;AACzC,MAAI,UAAU;AAEd,MAAI;AAEA,WAAO,gBAAgB,SAAS,yBAAyB,QAAQ;AAC7D,YAAMA,UAAS,IAAI,WAAW,MAAM;AACpC,MAAAA,QAAO,KAAK,KAAK;AACjB,aAAOA;AAAA,IACX;AAGA,WAAO,gBAAgB,SAAS,2BAA2B;AACvD,YAAM,cAAc,GAAG,eAAe,OAAO,cAAc,EAAE,GAAG,GAAG,KAAK,MAAM,CAAC;AAC/E,aAAO,IAAI;AAAA,QACP,KAAK,QAAQ;AAAA,QACb,KAAK,UAAU;AAAA,QACf;AAAA,MACJ,CAAC;AAAA,IACL;AAEA,QAAI,SAAS,MAAM;AACnB,QAAI,aAAa,GAAG,MAAM,GAAG;AACzB,gBAAU;AACV,eAAS,QAAQ,QAAQ,MAAM,EAAE,QAAQ,MAAM;AAAA,IACnD;AAEA,WAAO;AAAA,EACX,UAAE;AACE,QAAI,CAAC,SAAS;AACV,aAAO;AAAA,IACX;AAAA,EACJ;AAEA,WAAS,SAAS;AACd,WAAO,gBAAgB;AACvB,WAAO,gBAAgB;AAAA,EAC3B;AACJ;",
-  "names": ["result"]
-}

package/src/crypto/nonentropic.ts

@@ -1,65 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Project CHIP Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { ImplementationError } from "#MatterError.js";
-import { MaybePromise } from "#util/Promises.js";
-import { Crypto, ec } from "./Crypto.js";
-import { CurveType, Key, KeyType, PrivateKey } from "./Key.js";
-
-/**
- * WARNING: ONLY FOR USE IN PROTECTED TESTING ENVIRONMENTS WHERE SECURITY IS NOT A CONCERN
- *
- * Execute {@link actor} with sources of entropy replaced to produce stable values based on an input index.
- *
- * This is useful in testing environments where Matter logic is difficult to test with true entropy.
- *
- * I believe there are some crypto functions that are not fully mocked here but this covers current test cases.
- */
-export function nonentropic<T>(index: number, actor: () => T): T {
-    if (index < 0 || index > 255) {
-        throw new ImplementationError(`Index for stable crypto must be 0-255`);
-    }
-
-    const crypto = Crypto.default;
-    const { getRandomData, createKeyPair } = crypto;
-    let isAsync = false;
-
-    try {
-        // Create random data consisting of index repeated
-        crypto.getRandomData = function getRandomDataNONENTROPIC(length) {
-            const result = new Uint8Array(length);
-            result.fill(index);
-            return result;
-        };
-
-        // Ensure EC key generation uses our own "entropy" source rather than the platform's
-        crypto.createKeyPair = function getRandomDataNONENTROPIC() {
-            const privateBits = ec.mapHashToField(crypto.getRandomData(48), ec.p256.CURVE.n);
-            return Key({
-                kty: KeyType.EC,
-                crv: CurveType.p256,
-                privateBits,
-            }) as PrivateKey;
-        };
-
-        let result = actor();
-        if (MaybePromise.is(result)) {
-            isAsync = true;
-            result = Promise.resolve(result).finally(revert) as T;
-        }
-
-        return result;
-    } finally {
-        if (!isAsync) {
-            revert();
-        }
-    }
-
-    function revert() {
-        crypto.getRandomData = getRandomData;
-        crypto.createKeyPair = createKeyPair;
-    }
-}