@azure/msal-browser 3.0.0-alpha.1 → 3.0.0-alpha.2

package/dist/crypto/CryptoOps.js

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { PerformanceEvents, JoseHeader } from '@azure/msal-common';
 import { GuidGenerator } from './GuidGenerator.js';
@@ -10,155 +10,155 @@ import { BrowserStringUtils } from '../utils/BrowserStringUtils.js';
 import { BrowserAuthError } from '../error/BrowserAuthError.js';
 import { CryptoKeyStore } from '../cache/CryptoKeyStore.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * This class implements MSAL's crypto interface, which allows it to perform base64 encoding and decoding, generating cryptographically random GUIDs and
- * implementing Proof Key for Code Exchange specs for the OAuth Authorization Code Flow using PKCE (rfc here: https://tools.ietf.org/html/rfc7636).
- */
-class CryptoOps {
-    constructor(logger, performanceClient, cryptoConfig) {
-        this.logger = logger;
-        // Browser crypto needs to be validated first before any other classes can be set.
-        this.browserCrypto = new BrowserCrypto(this.logger, cryptoConfig);
-        this.b64Encode = new Base64Encode();
-        this.b64Decode = new Base64Decode();
-        this.guidGenerator = new GuidGenerator(this.browserCrypto);
-        this.pkceGenerator = new PkceGenerator(this.browserCrypto);
-        this.cache = new CryptoKeyStore(this.logger);
-        this.performanceClient = performanceClient;
-    }
-    /**
-     * Creates a new random GUID - used to populate state and nonce.
-     * @returns string (GUID)
-     */
-    createNewGuid() {
-        return this.guidGenerator.generateGuid();
-    }
-    /**
-     * Encodes input string to base64.
-     * @param input
-     */
-    base64Encode(input) {
-        return this.b64Encode.encode(input);
-    }
-    /**
-     * Decodes input string from base64.
-     * @param input
-     */
-    base64Decode(input) {
-        return this.b64Decode.decode(input);
-    }
-    /**
-     * Generates PKCE codes used in Authorization Code Flow.
-     */
-    async generatePkceCodes() {
-        return this.pkceGenerator.generateCodes();
-    }
-    /**
-     * Generates a keypair, stores it and returns a thumbprint
-     * @param request
-     */
-    async getPublicKeyThumbprint(request) {
-        const publicKeyThumbMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsGetPublicKeyThumbprint, request.correlationId);
-        // Generate Keypair
-        const keyPair = await this.browserCrypto.generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
-        // Generate Thumbprint for Public Key
-        const publicKeyJwk = await this.browserCrypto.exportJwk(keyPair.publicKey);
-        const pubKeyThumprintObj = {
-            e: publicKeyJwk.e,
-            kty: publicKeyJwk.kty,
-            n: publicKeyJwk.n,
-        };
-        const publicJwkString = BrowserStringUtils.getSortedObjectString(pubKeyThumprintObj);
-        const publicJwkHash = await this.hashString(publicJwkString);
-        // Generate Thumbprint for Private Key
-        const privateKeyJwk = await this.browserCrypto.exportJwk(keyPair.privateKey);
-        // Re-import private key to make it unextractable
-        const unextractablePrivateKey = await this.browserCrypto.importJwk(privateKeyJwk, false, ["sign"]);
-        // Store Keypair data in keystore
-        await this.cache.asymmetricKeys.setItem(publicJwkHash, {
-            privateKey: unextractablePrivateKey,
-            publicKey: keyPair.publicKey,
-            requestMethod: request.resourceRequestMethod,
-            requestUri: request.resourceRequestUri,
-        });
-        if (publicKeyThumbMeasurement) {
-            publicKeyThumbMeasurement.endMeasurement({
-                success: true,
-            });
-        }
-        return publicJwkHash;
-    }
-    /**
-     * Removes cryptographic keypair from key store matching the keyId passed in
-     * @param kid
-     */
-    async removeTokenBindingKey(kid) {
-        await this.cache.asymmetricKeys.removeItem(kid);
-        const keyFound = await this.cache.asymmetricKeys.containsKey(kid);
-        return !keyFound;
-    }
-    /**
-     * Removes all cryptographic keys from IndexedDB storage
-     */
-    async clearKeystore() {
-        return await this.cache.clear();
-    }
-    /**
-     * Signs the given object as a jwt payload with private key retrieved by given kid.
-     * @param payload
-     * @param kid
-     */
-    async signJwt(payload, kid, correlationId) {
-        const signJwtMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsSignJwt, correlationId);
-        const cachedKeyPair = await this.cache.asymmetricKeys.getItem(kid);
-        if (!cachedKeyPair) {
-            throw BrowserAuthError.createSigningKeyNotFoundInStorageError(kid);
-        }
-        // Get public key as JWK
-        const publicKeyJwk = await this.browserCrypto.exportJwk(cachedKeyPair.publicKey);
-        const publicKeyJwkString = BrowserStringUtils.getSortedObjectString(publicKeyJwk);
-        // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
-        const encodedKeyIdThumbprint = this.b64Encode.urlEncode(JSON.stringify({ kid: kid }));
-        // Generate header
-        const shrHeader = JoseHeader.getShrHeaderString({
-            kid: encodedKeyIdThumbprint,
-            alg: publicKeyJwk.alg,
-        });
-        const encodedShrHeader = this.b64Encode.urlEncode(shrHeader);
-        // Generate payload
-        payload.cnf = {
-            jwk: JSON.parse(publicKeyJwkString),
-        };
-        const encodedPayload = this.b64Encode.urlEncode(JSON.stringify(payload));
-        // Form token string
-        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
-        // Sign token
-        const tokenBuffer = BrowserStringUtils.stringToArrayBuffer(tokenString);
-        const signatureBuffer = await this.browserCrypto.sign(cachedKeyPair.privateKey, tokenBuffer);
-        const encodedSignature = this.b64Encode.urlEncodeArr(new Uint8Array(signatureBuffer));
-        const signedJwt = `${tokenString}.${encodedSignature}`;
-        if (signJwtMeasurement) {
-            signJwtMeasurement.endMeasurement({
-                success: true,
-            });
-        }
-        return signedJwt;
-    }
-    /**
-     * Returns the SHA-256 hash of an input string
-     * @param plainText
-     */
-    async hashString(plainText) {
-        const hashBuffer = await this.browserCrypto.sha256Digest(plainText);
-        const hashBytes = new Uint8Array(hashBuffer);
-        return this.b64Encode.urlEncodeArr(hashBytes);
-    }
-}
-CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * This class implements MSAL's crypto interface, which allows it to perform base64 encoding and decoding, generating cryptographically random GUIDs and
+ * implementing Proof Key for Code Exchange specs for the OAuth Authorization Code Flow using PKCE (rfc here: https://tools.ietf.org/html/rfc7636).
+ */
+class CryptoOps {
+    constructor(logger, performanceClient, cryptoConfig) {
+        this.logger = logger;
+        // Browser crypto needs to be validated first before any other classes can be set.
+        this.browserCrypto = new BrowserCrypto(this.logger, cryptoConfig);
+        this.b64Encode = new Base64Encode();
+        this.b64Decode = new Base64Decode();
+        this.guidGenerator = new GuidGenerator(this.browserCrypto);
+        this.pkceGenerator = new PkceGenerator(this.browserCrypto);
+        this.cache = new CryptoKeyStore(this.logger);
+        this.performanceClient = performanceClient;
+    }
+    /**
+     * Creates a new random GUID - used to populate state and nonce.
+     * @returns string (GUID)
+     */
+    createNewGuid() {
+        return this.guidGenerator.generateGuid();
+    }
+    /**
+     * Encodes input string to base64.
+     * @param input
+     */
+    base64Encode(input) {
+        return this.b64Encode.encode(input);
+    }
+    /**
+     * Decodes input string from base64.
+     * @param input
+     */
+    base64Decode(input) {
+        return this.b64Decode.decode(input);
+    }
+    /**
+     * Generates PKCE codes used in Authorization Code Flow.
+     */
+    async generatePkceCodes() {
+        return this.pkceGenerator.generateCodes();
+    }
+    /**
+     * Generates a keypair, stores it and returns a thumbprint
+     * @param request
+     */
+    async getPublicKeyThumbprint(request) {
+        const publicKeyThumbMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsGetPublicKeyThumbprint, request.correlationId);
+        // Generate Keypair
+        const keyPair = await this.browserCrypto.generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
+        // Generate Thumbprint for Public Key
+        const publicKeyJwk = await this.browserCrypto.exportJwk(keyPair.publicKey);
+        const pubKeyThumprintObj = {
+            e: publicKeyJwk.e,
+            kty: publicKeyJwk.kty,
+            n: publicKeyJwk.n,
+        };
+        const publicJwkString = BrowserStringUtils.getSortedObjectString(pubKeyThumprintObj);
+        const publicJwkHash = await this.hashString(publicJwkString);
+        // Generate Thumbprint for Private Key
+        const privateKeyJwk = await this.browserCrypto.exportJwk(keyPair.privateKey);
+        // Re-import private key to make it unextractable
+        const unextractablePrivateKey = await this.browserCrypto.importJwk(privateKeyJwk, false, ["sign"]);
+        // Store Keypair data in keystore
+        await this.cache.asymmetricKeys.setItem(publicJwkHash, {
+            privateKey: unextractablePrivateKey,
+            publicKey: keyPair.publicKey,
+            requestMethod: request.resourceRequestMethod,
+            requestUri: request.resourceRequestUri,
+        });
+        if (publicKeyThumbMeasurement) {
+            publicKeyThumbMeasurement.endMeasurement({
+                success: true,
+            });
+        }
+        return publicJwkHash;
+    }
+    /**
+     * Removes cryptographic keypair from key store matching the keyId passed in
+     * @param kid
+     */
+    async removeTokenBindingKey(kid) {
+        await this.cache.asymmetricKeys.removeItem(kid);
+        const keyFound = await this.cache.asymmetricKeys.containsKey(kid);
+        return !keyFound;
+    }
+    /**
+     * Removes all cryptographic keys from IndexedDB storage
+     */
+    async clearKeystore() {
+        return await this.cache.clear();
+    }
+    /**
+     * Signs the given object as a jwt payload with private key retrieved by given kid.
+     * @param payload
+     * @param kid
+     */
+    async signJwt(payload, kid, correlationId) {
+        const signJwtMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsSignJwt, correlationId);
+        const cachedKeyPair = await this.cache.asymmetricKeys.getItem(kid);
+        if (!cachedKeyPair) {
+            throw BrowserAuthError.createSigningKeyNotFoundInStorageError(kid);
+        }
+        // Get public key as JWK
+        const publicKeyJwk = await this.browserCrypto.exportJwk(cachedKeyPair.publicKey);
+        const publicKeyJwkString = BrowserStringUtils.getSortedObjectString(publicKeyJwk);
+        // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
+        const encodedKeyIdThumbprint = this.b64Encode.urlEncode(JSON.stringify({ kid: kid }));
+        // Generate header
+        const shrHeader = JoseHeader.getShrHeaderString({
+            kid: encodedKeyIdThumbprint,
+            alg: publicKeyJwk.alg,
+        });
+        const encodedShrHeader = this.b64Encode.urlEncode(shrHeader);
+        // Generate payload
+        payload.cnf = {
+            jwk: JSON.parse(publicKeyJwkString),
+        };
+        const encodedPayload = this.b64Encode.urlEncode(JSON.stringify(payload));
+        // Form token string
+        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
+        // Sign token
+        const tokenBuffer = BrowserStringUtils.stringToArrayBuffer(tokenString);
+        const signatureBuffer = await this.browserCrypto.sign(cachedKeyPair.privateKey, tokenBuffer);
+        const encodedSignature = this.b64Encode.urlEncodeArr(new Uint8Array(signatureBuffer));
+        const signedJwt = `${tokenString}.${encodedSignature}`;
+        if (signJwtMeasurement) {
+            signJwtMeasurement.endMeasurement({
+                success: true,
+            });
+        }
+        return signedJwt;
+    }
+    /**
+     * Returns the SHA-256 hash of an input string
+     * @param plainText
+     */
+    async hashString(plainText) {
+        const hashBuffer = await this.browserCrypto.sha256Digest(plainText);
+        const hashBytes = new Uint8Array(hashBuffer);
+        return this.b64Encode.urlEncodeArr(hashBytes);
+    }
+}
+CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
 CryptoOps.EXTRACTABLE = true;
 
 export { CryptoOps };

package/dist/crypto/GuidGenerator.d.ts

@@ -1,13 +1,13 @@
-import { IGuidGenerator } from "@azure/msal-common";
-import { BrowserCrypto } from "./BrowserCrypto";
-export declare class GuidGenerator implements IGuidGenerator {
-    private cryptoObj;
-    constructor(cryptoObj: BrowserCrypto);
-    generateGuid(): string;
-    /**
-     * verifies if a string is  GUID
-     * @param guid
-     */
-    isGuid(guid: string): boolean;
-}
+import { IGuidGenerator } from "@azure/msal-common";
+import { BrowserCrypto } from "./BrowserCrypto";
+export declare class GuidGenerator implements IGuidGenerator {
+    private cryptoObj;
+    constructor(cryptoObj: BrowserCrypto);
+    generateGuid(): string;
+    /**
+     * verifies if a string is  GUID
+     * @param guid
+     */
+    isGuid(guid: string): boolean;
+}
 //# sourceMappingURL=GuidGenerator.d.ts.map

package/dist/crypto/GuidGenerator.js

@@ -1,103 +1,103 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { Constants } from '@azure/msal-common';
 import { MathUtils } from '../utils/MathUtils.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class GuidGenerator {
-    constructor(cryptoObj) {
-        this.cryptoObj = cryptoObj;
-    }
-    /*
-     * RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
-     * pseudo-random numbers.
-     * The algorithm is as follows:
-     *     Set the two most significant bits (bits 6 and 7) of the
-     *        clock_seq_hi_and_reserved to zero and one, respectively.
-     *     Set the four most significant bits (bits 12 through 15) of the
-     *        time_hi_and_version field to the 4-bit version number from
-     *        Section 4.1.3. Version4
-     *     Set all the other bits to randomly (or pseudo-randomly) chosen
-     *     values.
-     * UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
-     * time-low               = 4hexOctet
-     * time-mid               = 2hexOctet
-     * time-high-and-version  = 2hexOctet
-     * clock-seq-and-reserved = hexOctet:
-     * clock-seq-low          = hexOctet
-     * node                   = 6hexOctet
-     * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
-     * y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
-     * y values are 8, 9, A, B
-     */
-    generateGuid() {
-        try {
-            const buffer = new Uint8Array(16);
-            this.cryptoObj.getRandomValues(buffer);
-            // buffer[6] and buffer[7] represents the time_hi_and_version field. We will set the four most significant bits (4 through 7) of buffer[6] to represent decimal number 4 (UUID version number).
-            buffer[6] |= 0x40; // buffer[6] | 01000000 will set the 6 bit to 1.
-            buffer[6] &= 0x4f; // buffer[6] & 01001111 will set the 4, 5, and 7 bit to 0 such that bits 4-7 == 0100 = "4".
-            // buffer[8] represents the clock_seq_hi_and_reserved field. We will set the two most significant bits (6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively.
-            buffer[8] |= 0x80; // buffer[8] | 10000000 will set the 7 bit to 1.
-            buffer[8] &= 0xbf; // buffer[8] & 10111111 will set the 6 bit to 0.
-            return (MathUtils.decimalToHex(buffer[0]) +
-                MathUtils.decimalToHex(buffer[1]) +
-                MathUtils.decimalToHex(buffer[2]) +
-                MathUtils.decimalToHex(buffer[3]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[4]) +
-                MathUtils.decimalToHex(buffer[5]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[6]) +
-                MathUtils.decimalToHex(buffer[7]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[8]) +
-                MathUtils.decimalToHex(buffer[9]) +
-                "-" +
-                MathUtils.decimalToHex(buffer[10]) +
-                MathUtils.decimalToHex(buffer[11]) +
-                MathUtils.decimalToHex(buffer[12]) +
-                MathUtils.decimalToHex(buffer[13]) +
-                MathUtils.decimalToHex(buffer[14]) +
-                MathUtils.decimalToHex(buffer[15]));
-        }
-        catch (err) {
-            const guidHolder = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
-            const hex = "0123456789abcdef";
-            let r = 0;
-            let guidResponse = Constants.EMPTY_STRING;
-            for (let i = 0; i < 36; i++) {
-                if (guidHolder[i] !== "-" && guidHolder[i] !== "4") {
-                    // each x and y needs to be random
-                    r = (Math.random() * 16) | 0;
-                }
-                if (guidHolder[i] === "x") {
-                    guidResponse += hex[r];
-                }
-                else if (guidHolder[i] === "y") {
-                    // clock-seq-and-reserved first hex is filtered and remaining hex values are random
-                    r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
-                    r |= 0x8; // set pos 3 to 1 as 1???
-                    guidResponse += hex[r];
-                }
-                else {
-                    guidResponse += guidHolder[i];
-                }
-            }
-            return guidResponse;
-        }
-    }
-    /**
-     * verifies if a string is  GUID
-     * @param guid
-     */
-    isGuid(guid) {
-        const regexGuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-        return regexGuid.test(guid);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class GuidGenerator {
+    constructor(cryptoObj) {
+        this.cryptoObj = cryptoObj;
+    }
+    /*
+     * RFC4122: The version 4 UUID is meant for generating UUIDs from truly-random or
+     * pseudo-random numbers.
+     * The algorithm is as follows:
+     *     Set the two most significant bits (bits 6 and 7) of the
+     *        clock_seq_hi_and_reserved to zero and one, respectively.
+     *     Set the four most significant bits (bits 12 through 15) of the
+     *        time_hi_and_version field to the 4-bit version number from
+     *        Section 4.1.3. Version4
+     *     Set all the other bits to randomly (or pseudo-randomly) chosen
+     *     values.
+     * UUID                   = time-low "-" time-mid "-"time-high-and-version "-"clock-seq-reserved and low(2hexOctet)"-" node
+     * time-low               = 4hexOctet
+     * time-mid               = 2hexOctet
+     * time-high-and-version  = 2hexOctet
+     * clock-seq-and-reserved = hexOctet:
+     * clock-seq-low          = hexOctet
+     * node                   = 6hexOctet
+     * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+     * y could be 1000, 1001, 1010, 1011 since most significant two bits needs to be 10
+     * y values are 8, 9, A, B
+     */
+    generateGuid() {
+        try {
+            const buffer = new Uint8Array(16);
+            this.cryptoObj.getRandomValues(buffer);
+            // buffer[6] and buffer[7] represents the time_hi_and_version field. We will set the four most significant bits (4 through 7) of buffer[6] to represent decimal number 4 (UUID version number).
+            buffer[6] |= 0x40; // buffer[6] | 01000000 will set the 6 bit to 1.
+            buffer[6] &= 0x4f; // buffer[6] & 01001111 will set the 4, 5, and 7 bit to 0 such that bits 4-7 == 0100 = "4".
+            // buffer[8] represents the clock_seq_hi_and_reserved field. We will set the two most significant bits (6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively.
+            buffer[8] |= 0x80; // buffer[8] | 10000000 will set the 7 bit to 1.
+            buffer[8] &= 0xbf; // buffer[8] & 10111111 will set the 6 bit to 0.
+            return (MathUtils.decimalToHex(buffer[0]) +
+                MathUtils.decimalToHex(buffer[1]) +
+                MathUtils.decimalToHex(buffer[2]) +
+                MathUtils.decimalToHex(buffer[3]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[4]) +
+                MathUtils.decimalToHex(buffer[5]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[6]) +
+                MathUtils.decimalToHex(buffer[7]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[8]) +
+                MathUtils.decimalToHex(buffer[9]) +
+                "-" +
+                MathUtils.decimalToHex(buffer[10]) +
+                MathUtils.decimalToHex(buffer[11]) +
+                MathUtils.decimalToHex(buffer[12]) +
+                MathUtils.decimalToHex(buffer[13]) +
+                MathUtils.decimalToHex(buffer[14]) +
+                MathUtils.decimalToHex(buffer[15]));
+        }
+        catch (err) {
+            const guidHolder = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+            const hex = "0123456789abcdef";
+            let r = 0;
+            let guidResponse = Constants.EMPTY_STRING;
+            for (let i = 0; i < 36; i++) {
+                if (guidHolder[i] !== "-" && guidHolder[i] !== "4") {
+                    // each x and y needs to be random
+                    r = (Math.random() * 16) | 0;
+                }
+                if (guidHolder[i] === "x") {
+                    guidResponse += hex[r];
+                }
+                else if (guidHolder[i] === "y") {
+                    // clock-seq-and-reserved first hex is filtered and remaining hex values are random
+                    r &= 0x3; // bit and with 0011 to set pos 2 to zero ?0??
+                    r |= 0x8; // set pos 3 to 1 as 1???
+                    guidResponse += hex[r];
+                }
+                else {
+                    guidResponse += guidHolder[i];
+                }
+            }
+            return guidResponse;
+        }
+    }
+    /**
+     * verifies if a string is  GUID
+     * @param guid
+     */
+    isGuid(guid) {
+        const regexGuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return regexGuid.test(guid);
+    }
 }
 
 export { GuidGenerator };

package/dist/crypto/ISubtleCrypto.d.ts

@@ -1,10 +1,10 @@
-export interface ISubtleCrypto {
-    initPrng?(entropy: Uint8Array): void;
-    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
-    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
-    exportKey(key: CryptoKey): Promise<JsonWebKey>;
-    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
-    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
-}
+export interface ISubtleCrypto {
+    initPrng?(entropy: Uint8Array): void;
+    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
+    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+    exportKey(key: CryptoKey): Promise<JsonWebKey>;
+    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
+}
 //# sourceMappingURL=ISubtleCrypto.d.ts.map

package/dist/crypto/ModernBrowserCrypto.d.ts

@@ -1,10 +1,10 @@
-import { ISubtleCrypto } from "./ISubtleCrypto";
-export declare class ModernBrowserCrypto implements ISubtleCrypto {
-    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
-    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
-    exportKey(key: CryptoKey): Promise<JsonWebKey>;
-    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
-    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
-}
+import { ISubtleCrypto } from "./ISubtleCrypto";
+export declare class ModernBrowserCrypto implements ISubtleCrypto {
+    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
+    generateKey(algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKeyPair>;
+    exportKey(key: CryptoKey): Promise<JsonWebKey>;
+    importKey(keyData: JsonWebKey, algorithm: RsaHashedImportParams, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+    digest(algorithm: AlgorithmIdentifier, data: Uint8Array): Promise<ArrayBuffer>;
+}
 //# sourceMappingURL=ModernBrowserCrypto.d.ts.map

package/dist/crypto/ModernBrowserCrypto.js

@@ -1,30 +1,30 @@
-/*! @azure/msal-browser v3.0.0-alpha.1 2023-05-08 */
+/*! @azure/msal-browser v3.0.0-alpha.2 2023-05-17 */
 'use strict';
 import { KEY_FORMAT_JWK } from '../utils/BrowserConstants.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-class ModernBrowserCrypto {
-    getRandomValues(dataBuffer) {
-        return window.crypto.getRandomValues(dataBuffer);
-    }
-    async generateKey(algorithm, extractable, keyUsages) {
-        return window.crypto.subtle.generateKey(algorithm, extractable, keyUsages);
-    }
-    async exportKey(key) {
-        return window.crypto.subtle.exportKey(KEY_FORMAT_JWK, key);
-    }
-    async importKey(keyData, algorithm, extractable, keyUsages) {
-        return window.crypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
-    }
-    async sign(algorithm, key, data) {
-        return window.crypto.subtle.sign(algorithm, key, data);
-    }
-    async digest(algorithm, data) {
-        return window.crypto.subtle.digest(algorithm, data);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+class ModernBrowserCrypto {
+    getRandomValues(dataBuffer) {
+        return window.crypto.getRandomValues(dataBuffer);
+    }
+    async generateKey(algorithm, extractable, keyUsages) {
+        return window.crypto.subtle.generateKey(algorithm, extractable, keyUsages);
+    }
+    async exportKey(key) {
+        return window.crypto.subtle.exportKey(KEY_FORMAT_JWK, key);
+    }
+    async importKey(keyData, algorithm, extractable, keyUsages) {
+        return window.crypto.subtle.importKey(KEY_FORMAT_JWK, keyData, algorithm, extractable, keyUsages);
+    }
+    async sign(algorithm, key, data) {
+        return window.crypto.subtle.sign(algorithm, key, data);
+    }
+    async digest(algorithm, data) {
+        return window.crypto.subtle.digest(algorithm, data);
+    }
 }
 
 export { ModernBrowserCrypto };