@azure/msal-browser 3.1.0 → 3.2.0

package/dist/crypto/BrowserCrypto.d.ts

@@ -1,50 +1,45 @@
-import { Logger } from "@azure/msal-common";
-/**
- * This class implements functions used by the browser library to perform cryptography operations such as
- * hashing and encoding. It also has helper functions to validate the availability of specific APIs.
- */
-export declare class BrowserCrypto {
-    private keygenAlgorithmOptions;
-    private subtleCrypto;
-    private logger;
-    constructor(logger: Logger);
-    /**
-     * Check whether browser crypto is available.
-     */
-    private hasBrowserCrypto;
-    /**
-     * Returns a sha-256 hash of the given dataString as an ArrayBuffer.
-     * @param dataString
-     */
-    sha256Digest(dataString: string): Promise<ArrayBuffer>;
-    /**
-     * Populates buffer with cryptographically random values.
-     * @param dataBuffer
-     */
-    getRandomValues(dataBuffer: Uint8Array): Uint8Array;
-    /**
-     * Generates a keypair based on current keygen algorithm config.
-     * @param extractable
-     * @param usages
-     */
-    generateKeyPair(extractable: boolean, usages: Array<KeyUsage>): Promise<CryptoKeyPair>;
-    /**
-     * Export key as Json Web Key (JWK)
-     * @param key
-     */
-    exportJwk(key: CryptoKey): Promise<JsonWebKey>;
-    /**
-     * Imports key as Json Web Key (JWK), can set extractable and usages.
-     * @param key
-     * @param extractable
-     * @param usages
-     */
-    importJwk(key: JsonWebKey, extractable: boolean, usages: Array<KeyUsage>): Promise<CryptoKey>;
-    /**
-     * Signs given data with given key
-     * @param key
-     * @param data
-     */
-    sign(key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-}
+import { IPerformanceClient, Logger } from "@azure/msal-common";
+/**
+ * Check whether browser crypto is available.
+ */
+export declare function validateCryptoAvailable(logger: Logger): void;
+/**
+ * Returns a sha-256 hash of the given dataString as an ArrayBuffer.
+ * @param dataString
+ */
+export declare function sha256Digest(dataString: string, performanceClient?: IPerformanceClient, correlationId?: string): Promise<ArrayBuffer>;
+/**
+ * Populates buffer with cryptographically random values.
+ * @param dataBuffer
+ */
+export declare function getRandomValues(dataBuffer: Uint8Array): Uint8Array;
+/**
+ * Creates a new random GUID
+ * @returns
+ */
+export declare function createNewGuid(): string;
+/**
+ * Generates a keypair based on current keygen algorithm config.
+ * @param extractable
+ * @param usages
+ */
+export declare function generateKeyPair(extractable: boolean, usages: Array<KeyUsage>): Promise<CryptoKeyPair>;
+/**
+ * Export key as Json Web Key (JWK)
+ * @param key
+ */
+export declare function exportJwk(key: CryptoKey): Promise<JsonWebKey>;
+/**
+ * Imports key as Json Web Key (JWK), can set extractable and usages.
+ * @param key
+ * @param extractable
+ * @param usages
+ */
+export declare function importJwk(key: JsonWebKey, extractable: boolean, usages: Array<KeyUsage>): Promise<CryptoKey>;
+/**
+ * Signs given data with given key
+ * @param key
+ * @param data
+ */
+export declare function sign(key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
 //# sourceMappingURL=BrowserCrypto.d.ts.map

package/dist/crypto/BrowserCrypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserCrypto.d.ts","sourceRoot":"","sources":["../../src/crypto/BrowserCrypto.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAa5C;;;GAGG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,sBAAsB,CAAwB;IACtD,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,MAAM;IAwB1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;OAGG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAM5D;;;OAGG;IACH,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU;IAInD;;;;OAIG;IACG,eAAe,CACjB,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GACxB,OAAO,CAAC,aAAa,CAAC;IAQzB;;;OAGG;IACG,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;IAIpD;;;;;OAKG;IACG,SAAS,CACX,GAAG,EAAE,UAAU,EACf,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GACxB,OAAO,CAAC,SAAS,CAAC;IASrB;;;;OAIG;IACG,IAAI,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;CAGtE"}
+{"version":3,"file":"BrowserCrypto.d.ts","sourceRoot":"","sources":["../../src/crypto/BrowserCrypto.ts"],"names":[],"mappings":"AAUA,OAAO,EACH,kBAAkB,EAClB,MAAM,EAET,MAAM,oBAAoB,CAAC;AA2B5B;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAO5D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAC9B,UAAU,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,kBAAkB,EACtC,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,WAAW,CAAC,CAUtB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAElE;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACjC,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GACxB,OAAO,CAAC,aAAa,CAAC,CAMxB;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAKnE;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAC3B,GAAG,EAAE,UAAU,EACf,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GACxB,OAAO,CAAC,SAAS,CAAC,CAQpB;AAED;;;;GAIG;AACH,wBAAsB,IAAI,CACtB,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,CAAC,CAMtB"}

package/dist/crypto/BrowserCrypto.mjs

@@ -1,14 +1,19 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
 import { BrowserStringUtils } from '../utils/BrowserStringUtils.mjs';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
-import { ModernBrowserCrypto } from './ModernBrowserCrypto.mjs';
+import { PerformanceEvents } from '@azure/msal-common';
+import { KEY_FORMAT_JWK } from '../utils/BrowserConstants.mjs';
 import { cryptoNonExistent } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+/**
+ * This file defines functions used by the browser library to perform cryptography operations such as
+ * hashing and encoding. It also has helper functions to validate the availability of specific APIs.
+ */
 /**
  * See here for more info on RsaHashedKeyGenParams: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
  */
@@ -20,84 +25,79 @@ const S256_HASH_ALG = "SHA-256";
 const MODULUS_LENGTH = 2048;
 // Public Exponent
 const PUBLIC_EXPONENT = new Uint8Array([0x01, 0x00, 0x01]);
+const keygenAlgorithmOptions = {
+    name: PKCS1_V15_KEYGEN_ALG,
+    hash: S256_HASH_ALG,
+    modulusLength: MODULUS_LENGTH,
+    publicExponent: PUBLIC_EXPONENT,
+};
 /**
- * This class implements functions used by the browser library to perform cryptography operations such as
- * hashing and encoding. It also has helper functions to validate the availability of specific APIs.
+ * Check whether browser crypto is available.
  */
-class BrowserCrypto {
-    constructor(logger) {
-        this.logger = logger;
-        if (this.hasBrowserCrypto()) {
-            // Use standard modern web crypto if available
-            this.logger.verbose("BrowserCrypto: modern crypto interface available");
-            this.subtleCrypto = new ModernBrowserCrypto();
-        }
-        else {
-            this.logger.error("BrowserCrypto: crypto interface is unavailable");
-            throw createBrowserAuthError(cryptoNonExistent);
-        }
-        this.keygenAlgorithmOptions = {
-            name: PKCS1_V15_KEYGEN_ALG,
-            hash: S256_HASH_ALG,
-            modulusLength: MODULUS_LENGTH,
-            publicExponent: PUBLIC_EXPONENT,
-        };
-    }
-    /**
-     * Check whether browser crypto is available.
-     */
-    hasBrowserCrypto() {
-        return "crypto" in window;
-    }
-    /**
-     * Returns a sha-256 hash of the given dataString as an ArrayBuffer.
-     * @param dataString
-     */
-    async sha256Digest(dataString) {
-        const data = BrowserStringUtils.stringToUtf8Arr(dataString);
-        // MSR Crypto wants object with name property, instead of string
-        return this.subtleCrypto.digest({ name: S256_HASH_ALG }, data);
-    }
-    /**
-     * Populates buffer with cryptographically random values.
-     * @param dataBuffer
-     */
-    getRandomValues(dataBuffer) {
-        return this.subtleCrypto.getRandomValues(dataBuffer);
-    }
-    /**
-     * Generates a keypair based on current keygen algorithm config.
-     * @param extractable
-     * @param usages
-     */
-    async generateKeyPair(extractable, usages) {
-        return this.subtleCrypto.generateKey(this.keygenAlgorithmOptions, extractable, usages);
+function validateCryptoAvailable(logger) {
+    if ("crypto" in window) {
+        logger.verbose("BrowserCrypto: modern crypto interface available");
     }
-    /**
-     * Export key as Json Web Key (JWK)
-     * @param key
-     */
-    async exportJwk(key) {
-        return this.subtleCrypto.exportKey(key);
-    }
-    /**
-     * Imports key as Json Web Key (JWK), can set extractable and usages.
-     * @param key
-     * @param extractable
-     * @param usages
-     */
-    async importJwk(key, extractable, usages) {
-        return this.subtleCrypto.importKey(key, this.keygenAlgorithmOptions, extractable, usages);
-    }
-    /**
-     * Signs given data with given key
-     * @param key
-     * @param data
-     */
-    async sign(key, data) {
-        return this.subtleCrypto.sign(this.keygenAlgorithmOptions, key, data);
+    else {
+        logger.error("BrowserCrypto: crypto interface is unavailable");
+        throw createBrowserAuthError(cryptoNonExistent);
     }
 }
+/**
+ * Returns a sha-256 hash of the given dataString as an ArrayBuffer.
+ * @param dataString
+ */
+async function sha256Digest(dataString, performanceClient, correlationId) {
+    performanceClient?.addQueueMeasurement(PerformanceEvents.Sha256Digest, correlationId);
+    const data = BrowserStringUtils.stringToUtf8Arr(dataString);
+    return window.crypto.subtle.digest(S256_HASH_ALG, data);
+}
+/**
+ * Populates buffer with cryptographically random values.
+ * @param dataBuffer
+ */
+function getRandomValues(dataBuffer) {
+    return window.crypto.getRandomValues(dataBuffer);
+}
+/**
+ * Creates a new random GUID
+ * @returns
+ */
+function createNewGuid() {
+    return window.crypto.randomUUID();
+}
+/**
+ * Generates a keypair based on current keygen algorithm config.
+ * @param extractable
+ * @param usages
+ */
+async function generateKeyPair(extractable, usages) {
+    return window.crypto.subtle.generateKey(keygenAlgorithmOptions, extractable, usages);
+}
+/**
+ * Export key as Json Web Key (JWK)
+ * @param key
+ */
+async function exportJwk(key) {
+    return window.crypto.subtle.exportKey(KEY_FORMAT_JWK, key);
+}
+/**
+ * Imports key as Json Web Key (JWK), can set extractable and usages.
+ * @param key
+ * @param extractable
+ * @param usages
+ */
+async function importJwk(key, extractable, usages) {
+    return window.crypto.subtle.importKey(KEY_FORMAT_JWK, key, keygenAlgorithmOptions, extractable, usages);
+}
+/**
+ * Signs given data with given key
+ * @param key
+ * @param data
+ */
+async function sign(key, data) {
+    return window.crypto.subtle.sign(keygenAlgorithmOptions, key, data);
+}
 
-export { BrowserCrypto };
+export { createNewGuid, exportJwk, generateKeyPair, getRandomValues, importJwk, sha256Digest, sign, validateCryptoAvailable };
 //# sourceMappingURL=BrowserCrypto.mjs.map

package/dist/crypto/BrowserCrypto.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"BrowserCrypto.mjs","sources":["../../src/crypto/BrowserCrypto.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAYA;AAaA;;;;;AASgB;AAwBZ;;AAEG;AACH,MAAA,aAAwB,GAAA,SAAA,CAAA;AAIxB;;;AAGG,MAAA,eAAA,GAAA,IAAA,UAAA,CAAA,CAAA,IAAA,EAAA,IAAA,EAAA,IAAA,CAAA,CAAA,CAAA;;AAOH;;;AAGG,MAAA,aAAA,CAAA;AACH,IAAA,WAAA,CAAA,MAAgB,EAAA;AAIhB,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;;;AAIG,YAAA,IAAA,CAAA,YAAA,GAAA,IAAA,mBAAA,EAAA,CAAA;AACG,SAAA;AAWN,aAAA;;;AAGG,SAAA;QACY,IAAA,CAAA,sBAAyB,GAAA;AAIxC,YAAA,IAAA,EAAA,oBAAA;;;;;AAKG,KAAA;AACG;AAaN;;;;AAIG,KAAA;AACG;AAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"BrowserCrypto.mjs","sources":["../../src/crypto/BrowserCrypto.ts"],"sourcesContent":[null],"names":["BrowserAuthErrorCodes.cryptoNonExistent"],"mappings":";;;;;;;;AAUA;AA+BA;;AAEG;AAaA;AACH;AAgBA;;;AAGG;AACH;AAIA;;;AAGG,MAAA,aAAA,GAAA,SAAA,CAAA;AACH;AAIA,MAAA,cAAA,GAAA,IAAA,CAAA;;;;AAIG,IAAA,IAAA,EAAA,oBAAA;AACH,IAAA,IAAA,EAAA,aAAA;AAWA,IAAA,aAAA,EAAA,cAAA;;;AAGG;AACH;AAOA;;;;;AAKG,SAAA;AACH,QAAsB,MAAA,CAAA,KAAA,CAAA,gDAEE,CAAA,CAAA;AAYxB,QAAA,MAAA,sBAAA,CAAAA,iBAAA,CAAA,CAAA;;;;AAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/CryptoOps.d.ts

@@ -1,4 +1,4 @@
-import { ICrypto, IPerformanceClient, Logger, PkceCodes, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
+import { ICrypto, IPerformanceClient, Logger, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
 export type CachedKeyPair = {
     publicKey: CryptoKey;
     privateKey: CryptoKey;
@@ -10,8 +10,6 @@ export type CachedKeyPair = {
  * implementing Proof Key for Code Exchange specs for the OAuth Authorization Code Flow using PKCE (rfc here: https://tools.ietf.org/html/rfc7636).
  */
 export declare class CryptoOps implements ICrypto {
-    private browserCrypto;
-    private pkceGenerator;
     private logger;
     /**
      * CryptoOps can be used in contexts outside a PCA instance,
@@ -37,10 +35,6 @@ export declare class CryptoOps implements ICrypto {
      * @param input
      */
     base64Decode(input: string): string;
-    /**
-     * Generates PKCE codes used in Authorization Code Flow.
-     */
-    generatePkceCodes(): Promise<PkceCodes>;
     /**
      * Generates a keypair, stores it and returns a thumbprint
      * @param request

package/dist/crypto/CryptoOps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CryptoOps.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoOps.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,OAAO,EACP,kBAAkB,EAElB,MAAM,EAEN,SAAS,EACT,iBAAiB,EACjB,2BAA2B,EAC9B,MAAM,oBAAoB,CAAC;AAY5B,MAAM,MAAM,aAAa,GAAG;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,SAAS,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,qBAAa,SAAU,YAAW,OAAO;IACrC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAiC;IAE1D,OAAO,CAAC,MAAM,CAAC,cAAc,CAAuC;IACpE,OAAO,CAAC,MAAM,CAAC,WAAW,CAAiB;IAC3C,OAAO,CAAC,KAAK,CAAiB;gBAElB,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,kBAAkB;IASlE;;;OAGG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInC;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC;IAI7C;;;OAGG;IACG,sBAAsB,CACxB,OAAO,EAAE,2BAA2B,GACrC,OAAO,CAAC,MAAM,CAAC;IAqDlB;;;OAGG;IACG,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM1D;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAIvC;;;;OAIG;IACG,OAAO,CACT,OAAO,EAAE,iBAAiB,EAC1B,GAAG,EAAE,MAAM,EACX,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC;IA0DlB;;;OAGG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAOvD"}
+{"version":3,"file":"CryptoOps.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoOps.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,OAAO,EACP,kBAAkB,EAElB,MAAM,EAEN,iBAAiB,EACjB,2BAA2B,EAC9B,MAAM,oBAAoB,CAAC;AAW5B,MAAM,MAAM,aAAa,GAAG;IACxB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,SAAS,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;GAGG;AACH,qBAAa,SAAU,YAAW,OAAO;IACrC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAiC;IAE1D,OAAO,CAAC,MAAM,CAAC,cAAc,CAAuC;IACpE,OAAO,CAAC,MAAM,CAAC,WAAW,CAAiB;IAC3C,OAAO,CAAC,KAAK,CAAiB;gBAElB,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,kBAAkB;IAQlE;;;OAGG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInC;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInC;;;OAGG;IACG,sBAAsB,CACxB,OAAO,EAAE,2BAA2B,GACrC,OAAO,CAAC,MAAM,CAAC;IAqDlB;;;OAGG;IACG,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM1D;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC;IAIvC;;;;OAIG;IACG,OAAO,CACT,OAAO,EAAE,iBAAiB,EAC1B,GAAG,EAAE,MAAM,EACX,aAAa,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,MAAM,CAAC;IA0DlB;;;OAGG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAOvD"}

package/dist/crypto/CryptoOps.mjs

@@ -1,10 +1,9 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
 import { PerformanceEvents, JoseHeader } from '@azure/msal-common';
 import { base64Encode, urlEncode, urlEncodeArr } from '../encode/Base64Encode.mjs';
 import { base64Decode } from '../encode/Base64Decode.mjs';
-import { PkceGenerator } from './PkceGenerator.mjs';
-import { BrowserCrypto } from './BrowserCrypto.mjs';
+import { validateCryptoAvailable, createNewGuid, generateKeyPair, exportJwk, importJwk, sign, sha256Digest } from './BrowserCrypto.mjs';
 import { BrowserStringUtils } from '../utils/BrowserStringUtils.mjs';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { CryptoKeyStore } from '../cache/CryptoKeyStore.mjs';
@@ -22,8 +21,7 @@ class CryptoOps {
     constructor(logger, performanceClient) {
         this.logger = logger;
         // Browser crypto needs to be validated first before any other classes can be set.
-        this.browserCrypto = new BrowserCrypto(this.logger);
-        this.pkceGenerator = new PkceGenerator(this.browserCrypto);
+        validateCryptoAvailable(logger);
         this.cache = new CryptoKeyStore(this.logger);
         this.performanceClient = performanceClient;
     }
@@ -32,7 +30,7 @@ class CryptoOps {
      * @returns string (GUID)
      */
     createNewGuid() {
-        return window.crypto.randomUUID();
+        return createNewGuid();
     }
     /**
      * Encodes input string to base64.
@@ -48,12 +46,6 @@ class CryptoOps {
     base64Decode(input) {
         return base64Decode(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
@@ -61,9 +53,9 @@ class CryptoOps {
     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);
+        const keyPair = await generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
         // Generate Thumbprint for Public Key
-        const publicKeyJwk = await this.browserCrypto.exportJwk(keyPair.publicKey);
+        const publicKeyJwk = await exportJwk(keyPair.publicKey);
         const pubKeyThumprintObj = {
             e: publicKeyJwk.e,
             kty: publicKeyJwk.kty,
@@ -72,9 +64,9 @@ class CryptoOps {
         const publicJwkString = BrowserStringUtils.getSortedObjectString(pubKeyThumprintObj);
         const publicJwkHash = await this.hashString(publicJwkString);
         // Generate Thumbprint for Private Key
-        const privateKeyJwk = await this.browserCrypto.exportJwk(keyPair.privateKey);
+        const privateKeyJwk = await exportJwk(keyPair.privateKey);
         // Re-import private key to make it unextractable
-        const unextractablePrivateKey = await this.browserCrypto.importJwk(privateKeyJwk, false, ["sign"]);
+        const unextractablePrivateKey = await importJwk(privateKeyJwk, false, ["sign"]);
         // Store Keypair data in keystore
         await this.cache.asymmetricKeys.setItem(publicJwkHash, {
             privateKey: unextractablePrivateKey,
@@ -116,7 +108,7 @@ class CryptoOps {
             throw createBrowserAuthError(cryptoKeyNotFound);
         }
         // Get public key as JWK
-        const publicKeyJwk = await this.browserCrypto.exportJwk(cachedKeyPair.publicKey);
+        const publicKeyJwk = await exportJwk(cachedKeyPair.publicKey);
         const publicKeyJwkString = BrowserStringUtils.getSortedObjectString(publicKeyJwk);
         // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
         const encodedKeyIdThumbprint = urlEncode(JSON.stringify({ kid: kid }));
@@ -135,7 +127,7 @@ class CryptoOps {
         const tokenString = `${encodedShrHeader}.${encodedPayload}`;
         // Sign token
         const tokenBuffer = BrowserStringUtils.stringToUtf8Arr(tokenString);
-        const signatureBuffer = await this.browserCrypto.sign(cachedKeyPair.privateKey, tokenBuffer);
+        const signatureBuffer = await sign(cachedKeyPair.privateKey, tokenBuffer);
         const encodedSignature = urlEncodeArr(new Uint8Array(signatureBuffer));
         const signedJwt = `${tokenString}.${encodedSignature}`;
         if (signJwtMeasurement) {
@@ -150,7 +142,7 @@ class CryptoOps {
      * @param plainText
      */
     async hashString(plainText) {
-        const hashBuffer = await this.browserCrypto.sha256Digest(plainText);
+        const hashBuffer = await sha256Digest(plainText);
         const hashBytes = new Uint8Array(hashBuffer);
         return urlEncodeArr(hashBytes);
     }

package/dist/crypto/CryptoOps.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;AAKA;AAqBA;;;;;;AAgBI;;;AAGG,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;AAGH,QAAA,IAAQ,CAAA,aAAO,GAAA,IAAc,aAAuC,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;AACpE,QAAA,IAAQ,CAAA,aAAO,GAAA,IAA4B,aAAA,CAAA,IAAA,CAAA,aAAA,CAAA,CAAA;QACpC,IAAC,MAAsB,GAAA,IAAA,cAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;AAElB,QAAA,IAAA,CAAA,iBAAc,GAAmB,iBAAC;AAS9C,KAAA;;;AAGG;AACH;AAIA,IAAA,aAAA,GAAA;;;AAGG;AACH;AAIA;;;AAGG,QAAA,OAAA,YAAA,CAAA,KAAA,CAAA,CAAA;AACH,KAAA;AAIA;;AAEG;AACG;AAIN,IAAA,YAAA,CAAA,KAAA,EAAA;;;AAGG;;AAwDH;;;AAGG,KAAA;;AAOH;;AAEG;AACG,IAAA,MAAA,sBAAyB,CAAA,OAAQ,EAAA;AAIvC,QAAA,MAAA,yBAAA,GAAA,IAAA,CAAA,iBAAA,EAAA,gBAAA,CAAA,iBAAA,CAAA,gCAAA,EAAA,OAAA,CAAA,aAAA,CAAA,CAAA;;;;AAIG,QAAA,MAAA,YAAA,GAAA,MAAA,IAAA,CAAA,aAAA,CAAA,SAAA,CAAA,OAAA,CAAA,SAAA,CAAA,CAAA;AACG,QAAA,MACK,kBAAmB,GAAA;AA6D9B,YAAA,CAAA,EAAA,YAAA,CAAA,CAAA;;;AAGG,SAAA,CAAA;QACa,MAAA,eAAY,GAAM,kBAAkB,CAAA,qBAAA,CAAA,kBAAA,CAAA,CAAA;AAOvD,QAAA,MAAA,aAAA,GAAA,MAAA,IAAA,CAAA,UAAA,CAAA,eAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":["BrowserCrypto.validateCryptoAvailable","BrowserCrypto.generateKeyPair","BrowserCrypto.exportJwk"],"mappings":";;;;;;;;;;;AAKA;AAmBA;;;AAWA;;AAGI;;;AAGG,IAAA,WAAA,CAAA,MAAA,EAAA,iBAAA,EAAA;QACI,IAAC,iBAAiB;AAEzB;AACA,QAAAA,uBAA2C,CAAA,MAAA,CAAA,CAAA;QACpC,IAAC,MAAsB,GAAA,IAAA,cAAA,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;AAElB,QAAA,IAAA,CAAA,iBAAc,GAAmB,iBAAC;AAQ9C,KAAA;;;AAGG;AACH;AAIA,IAAA,aAAA,GAAA;;;AAGG;AACH;AAIA;;;AAGG,QAAA,OAAA,YAAA,CAAA,KAAA,CAAA,CAAA;AACH,KAAA;AAIA;;;AAGG;IACG,YAAsB,CAAA,KAAA,EAAA;AAuD5B,QAAA,OAAA,YAAA,CAAA,KAAA,CAAA,CAAA;;;AAGG;;AAOH;;AAEG,QAAA,MAAA,yBAAA,GAAA,IAAA,CAAA,iBAAA,EAAA,gBAAA,CAAA,iBAAA,CAAA,gCAAA,EAAA,OAAA,CAAA,aAAA,CAAA,CAAA;AACG;AAIN,QAAA,MAAA,OAAA,GAAA,MAAAC,eAAA,CAAA,SAAA,CAAA,WAAA,EAAA,SAAA,CAAA,cAAA,CAAA,CAAA;;;;AAIG,YAAA,CAAA,EAAA,YAAA,CAAA,CAAA;AACG,YACF,GAAO,EAAA,YAAmB,CAAA,GAAA;AA6D9B,YAAA,CAAA,EAAA,YAAA,CAAA,CAAA;;;AAGG,QAAA,MAAA,aAAA,GAAA,MAAA,IAAA,CAAA,UAAA,CAAA,eAAA,CAAA,CAAA;;AAQN,QAAA,MAAA,aAAA,GAAA,MAAAC,SAAA,CAAA,OAAA,CAAA,UAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/PkceGenerator.d.ts

@@ -1,24 +1,9 @@
-import { PkceCodes } from "@azure/msal-common";
-import { BrowserCrypto } from "./BrowserCrypto";
+import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
 /**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
+ * This file defines APIs to generate PKCE codes and code verifiers.
  */
-export declare class PkceGenerator {
-    private cryptoObj;
-    constructor(cryptoObj: BrowserCrypto);
-    /**
-     * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
-     */
-    generateCodes(): Promise<PkceCodes>;
-    /**
-     * Generates a random 32 byte buffer and returns the base64
-     * encoded string to be used as a PKCE Code Verifier
-     */
-    private generateCodeVerifier;
-    /**
-     * Creates a base64 encoded PKCE Code Challenge string from the
-     * hash created from the PKCE Code Verifier supplied
-     */
-    private generateCodeChallengeFromVerifier;
-}
+/**
+ * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
+ */
+export declare function generatePkceCodes(performanceClient: IPerformanceClient, logger: Logger, correlationId: string): Promise<PkceCodes>;
 //# sourceMappingURL=PkceGenerator.d.ts.map

package/dist/crypto/PkceGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PkceGenerator.d.ts","sourceRoot":"","sources":["../../src/crypto/PkceGenerator.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAM/C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKhD;;GAEG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,SAAS,CAAgB;gBAErB,SAAS,EAAE,aAAa;IAIpC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,SAAS,CAAC;IAWzC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;OAGG;YACW,iCAAiC;CAclD"}
+{"version":3,"file":"PkceGenerator.d.ts","sourceRoot":"","sources":["../../src/crypto/PkceGenerator.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,kBAAkB,EAClB,MAAM,EAEN,SAAS,EAGZ,MAAM,oBAAoB,CAAC;AAW5B;;GAEG;AAEH;;GAEG;AACH,wBAAsB,iBAAiB,CACnC,iBAAiB,EAAE,kBAAkB,EACrC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACtB,OAAO,CAAC,SAAS,CAAC,CAuBpB"}

package/dist/crypto/PkceGenerator.mjs

@@ -1,7 +1,9 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
+import { PerformanceEvents, invoke, invokeAsync } from '@azure/msal-common';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { urlEncodeArr } from '../encode/Base64Encode.mjs';
+import { getRandomValues, sha256Digest } from './BrowserCrypto.mjs';
 import { pkceNotCreated } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
@@ -11,56 +13,53 @@ import { pkceNotCreated } from '../error/BrowserAuthErrorCodes.mjs';
 // Constant byte array length
 const RANDOM_BYTE_ARR_LENGTH = 32;
 /**
- * Class which exposes APIs to generate PKCE codes and code verifiers.
+ * This file defines APIs to generate PKCE codes and code verifiers.
  */
-class PkceGenerator {
-    constructor(cryptoObj) {
-        this.cryptoObj = cryptoObj;
+/**
+ * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
+ */
+async function generatePkceCodes(performanceClient, logger, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.GeneratePkceCodes, correlationId);
+    const codeVerifier = invoke(generateCodeVerifier, PerformanceEvents.GenerateCodeVerifier, logger, performanceClient, correlationId)(performanceClient, logger, correlationId);
+    const codeChallenge = await invokeAsync(generateCodeChallengeFromVerifier, PerformanceEvents.GenerateCodeChallengeFromVerifier, logger, performanceClient, correlationId)(codeVerifier, performanceClient, logger, correlationId);
+    return {
+        verifier: codeVerifier,
+        challenge: codeChallenge,
+    };
+}
+/**
+ * Generates a random 32 byte buffer and returns the base64
+ * encoded string to be used as a PKCE Code Verifier
+ */
+function generateCodeVerifier(performanceClient, logger, correlationId) {
+    try {
+        // Generate random values as utf-8
+        const buffer = new Uint8Array(RANDOM_BYTE_ARR_LENGTH);
+        invoke(getRandomValues, PerformanceEvents.GetRandomValues, logger, performanceClient, correlationId)(buffer);
+        // encode verifier as base64
+        const pkceCodeVerifierB64 = urlEncodeArr(buffer);
+        return pkceCodeVerifierB64;
     }
-    /**
-     * Generates PKCE Codes. See the RFC for more information: https://tools.ietf.org/html/rfc7636
-     */
-    async generateCodes() {
-        const codeVerifier = this.generateCodeVerifier();
-        const codeChallenge = await this.generateCodeChallengeFromVerifier(codeVerifier);
-        return {
-            verifier: codeVerifier,
-            challenge: codeChallenge,
-        };
+    catch (e) {
+        throw createBrowserAuthError(pkceNotCreated);
     }
-    /**
-     * Generates a random 32 byte buffer and returns the base64
-     * encoded string to be used as a PKCE Code Verifier
-     */
-    generateCodeVerifier() {
-        try {
-            // Generate random values as utf-8
-            const buffer = new Uint8Array(RANDOM_BYTE_ARR_LENGTH);
-            this.cryptoObj.getRandomValues(buffer);
-            // encode verifier as base64
-            const pkceCodeVerifierB64 = urlEncodeArr(buffer);
-            return pkceCodeVerifierB64;
-        }
-        catch (e) {
-            throw createBrowserAuthError(pkceNotCreated);
-        }
+}
+/**
+ * Creates a base64 encoded PKCE Code Challenge string from the
+ * hash created from the PKCE Code Verifier supplied
+ */
+async function generateCodeChallengeFromVerifier(pkceCodeVerifier, performanceClient, logger, correlationId) {
+    performanceClient.addQueueMeasurement(PerformanceEvents.GenerateCodeChallengeFromVerifier, correlationId);
+    try {
+        // hashed verifier
+        const pkceHashedCodeVerifier = await invokeAsync(sha256Digest, PerformanceEvents.Sha256Digest, logger, performanceClient, correlationId)(pkceCodeVerifier, performanceClient, correlationId);
+        // encode hash as base64
+        return urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
     }
-    /**
-     * Creates a base64 encoded PKCE Code Challenge string from the
-     * hash created from the PKCE Code Verifier supplied
-     */
-    async generateCodeChallengeFromVerifier(pkceCodeVerifier) {
-        try {
-            // hashed verifier
-            const pkceHashedCodeVerifier = await this.cryptoObj.sha256Digest(pkceCodeVerifier);
-            // encode hash as base64
-            return urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
-        }
-        catch (e) {
-            throw createBrowserAuthError(pkceNotCreated);
-        }
+    catch (e) {
+        throw createBrowserAuthError(pkceNotCreated);
     }
 }
 
-export { PkceGenerator };
+export { generatePkceCodes };
 //# sourceMappingURL=PkceGenerator.mjs.map

package/dist/crypto/PkceGenerator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"PkceGenerator.mjs","sources":["../../src/crypto/PkceGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAKA;AAMA;AAKA;;;AAMgB,MAAA,sBAAwB,GAAA,EAAA,CAAA;AAIpC;;AAEG;AACG,MAAA,aAAiB,CAAA;AAWvB,IAAA,WAAA,CAAA,SAAA,EAAA;;;AAGG;AACH;AAaA;;;AAGG,QAAA,MAAA,aAAA,GAAA,MAAA,IAAA,CAAA,iCAAA,CAAA,YAAA,CAAA,CAAA;eAC4C;AAclD,YAAA,QAAA,EAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"PkceGenerator.mjs","sources":["../../src/crypto/PkceGenerator.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;AAKA;AAkBA;;AAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/SignedHttpRequest.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
 import { CryptoOps } from './CryptoOps.mjs';
 import { Logger, PopTokenGenerator } from '@azure/msal-common';

package/dist/encode/Base64Decode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Base64Decode.d.ts","sourceRoot":"","sources":["../../src/encode/Base64Decode.ts"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}
+{"version":3,"file":"Base64Decode.d.ts","sourceRoot":"","sources":["../../src/encode/Base64Decode.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/encode/Base64Decode.mjs

@@ -1,5 +1,8 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
+import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
+import { invalidBase64String } from '../error/BrowserAuthErrorCodes.mjs';
+
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
@@ -20,7 +23,20 @@ function base64Decode(input) {
  * @param base64String
  */
 function base64DecToArr(base64String) {
-    const binString = atob(base64String);
+    let encodedString = base64String.replace(/-/g, "+").replace(/_/g, "/");
+    switch (encodedString.length % 4) {
+        case 0:
+            break;
+        case 2:
+            encodedString += "==";
+            break;
+        case 3:
+            encodedString += "=";
+            break;
+        default:
+            throw createBrowserAuthError(invalidBase64String);
+    }
+    const binString = atob(encodedString);
     return Uint8Array.from(binString, (m) => m.codePointAt(0) || 0);
 }
 

package/dist/encode/Base64Decode.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Base64Decode.mjs","sources":["../../src/encode/Base64Decode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;AAGG;AAEH;;;AAGG;AACH;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"Base64Decode.mjs","sources":["../../src/encode/Base64Decode.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;AAGG;;;AAKA;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/encode/Base64Encode.mjs

@@ -1,4 +1,4 @@
-/*! @azure/msal-browser v3.1.0 2023-09-05 */
+/*! @azure/msal-browser v3.2.0 2023-10-05 */
 'use strict';
 /*
  * Copyright (c) Microsoft Corporation. All rights reserved.