@azure/msal-browser 3.4.0 → 3.5.1-beta.0

package/dist/crypto/BrowserCrypto.mjs

@@ -1,102 +1,102 @@
-/*! @azure/msal-browser v3.4.0 2023-10-30 */
+/*! @azure/msal-browser v3.5.1-beta.0 2023-11-14 */
 'use strict';
 import { createBrowserAuthError } from '../error/BrowserAuthError.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
- */
-// RSA KeyGen Algorithm
-const PKCS1_V15_KEYGEN_ALG = "RSASSA-PKCS1-v1_5";
-// SHA-256 hashing algorithm
-const S256_HASH_ALG = "SHA-256";
-// MOD length for PoP tokens
-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,
-};
-/**
- * Check whether browser crypto is available.
- */
-function validateCryptoAvailable(logger) {
-    if ("crypto" in window) {
-        logger.verbose("BrowserCrypto: modern crypto interface available");
-    }
-    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 encoder = new TextEncoder();
-    const data = encoder.encode(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);
+/*
+ * 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
+ */
+// RSA KeyGen Algorithm
+const PKCS1_V15_KEYGEN_ALG = "RSASSA-PKCS1-v1_5";
+// SHA-256 hashing algorithm
+const S256_HASH_ALG = "SHA-256";
+// MOD length for PoP tokens
+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,
+};
+/**
+ * Check whether browser crypto is available.
+ */
+function validateCryptoAvailable(logger) {
+    if ("crypto" in window) {
+        logger.verbose("BrowserCrypto: modern crypto interface available");
+    }
+    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 encoder = new TextEncoder();
+    const data = encoder.encode(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 { createNewGuid, exportJwk, generateKeyPair, getRandomValues, importJwk, sha256Digest, sign, validateCryptoAvailable };

package/dist/crypto/CryptoOps.d.ts

@@ -1,64 +1,64 @@
-import { ICrypto, IPerformanceClient, Logger, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
-export type CachedKeyPair = {
-    publicKey: CryptoKey;
-    privateKey: CryptoKey;
-    requestMethod?: string;
-    requestUri?: string;
-};
-/**
- * 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).
- */
-export declare class CryptoOps implements ICrypto {
-    private logger;
-    /**
-     * CryptoOps can be used in contexts outside a PCA instance,
-     * meaning there won't be a performance manager available.
-     */
-    private performanceClient;
-    private static POP_KEY_USAGES;
-    private static EXTRACTABLE;
-    private cache;
-    constructor(logger: Logger, performanceClient?: IPerformanceClient);
-    /**
-     * Creates a new random GUID - used to populate state and nonce.
-     * @returns string (GUID)
-     */
-    createNewGuid(): string;
-    /**
-     * Encodes input string to base64.
-     * @param input
-     */
-    base64Encode(input: string): string;
-    /**
-     * Decodes input string from base64.
-     * @param input
-     */
-    base64Decode(input: string): string;
-    /**
-     * Generates a keypair, stores it and returns a thumbprint
-     * @param request
-     */
-    getPublicKeyThumbprint(request: SignedHttpRequestParameters): Promise<string>;
-    /**
-     * Removes cryptographic keypair from key store matching the keyId passed in
-     * @param kid
-     */
-    removeTokenBindingKey(kid: string): Promise<boolean>;
-    /**
-     * Removes all cryptographic keys from IndexedDB storage
-     */
-    clearKeystore(): Promise<boolean>;
-    /**
-     * Signs the given object as a jwt payload with private key retrieved by given kid.
-     * @param payload
-     * @param kid
-     */
-    signJwt(payload: SignedHttpRequest, kid: string, correlationId?: string): Promise<string>;
-    /**
-     * Returns the SHA-256 hash of an input string
-     * @param plainText
-     */
-    hashString(plainText: string): Promise<string>;
-}
+import { ICrypto, IPerformanceClient, Logger, ShrOptions, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
+export type CachedKeyPair = {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    requestMethod?: string;
+    requestUri?: string;
+};
+/**
+ * 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).
+ */
+export declare class CryptoOps implements ICrypto {
+    private logger;
+    /**
+     * CryptoOps can be used in contexts outside a PCA instance,
+     * meaning there won't be a performance manager available.
+     */
+    private performanceClient;
+    private static POP_KEY_USAGES;
+    private static EXTRACTABLE;
+    private cache;
+    constructor(logger: Logger, performanceClient?: IPerformanceClient);
+    /**
+     * Creates a new random GUID - used to populate state and nonce.
+     * @returns string (GUID)
+     */
+    createNewGuid(): string;
+    /**
+     * Encodes input string to base64.
+     * @param input
+     */
+    base64Encode(input: string): string;
+    /**
+     * Decodes input string from base64.
+     * @param input
+     */
+    base64Decode(input: string): string;
+    /**
+     * Generates a keypair, stores it and returns a thumbprint
+     * @param request
+     */
+    getPublicKeyThumbprint(request: SignedHttpRequestParameters): Promise<string>;
+    /**
+     * Removes cryptographic keypair from key store matching the keyId passed in
+     * @param kid
+     */
+    removeTokenBindingKey(kid: string): Promise<boolean>;
+    /**
+     * Removes all cryptographic keys from IndexedDB storage
+     */
+    clearKeystore(): Promise<boolean>;
+    /**
+     * Signs the given object as a jwt payload with private key retrieved by given kid.
+     * @param payload
+     * @param kid
+     */
+    signJwt(payload: SignedHttpRequest, kid: string, shrOptions?: ShrOptions, correlationId?: string): Promise<string>;
+    /**
+     * Returns the SHA-256 hash of an input string
+     * @param plainText
+     */
+    hashString(plainText: string): Promise<string>;
+}
 //# sourceMappingURL=CryptoOps.d.ts.map

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,iBAAiB,EACjB,2BAA2B,EAC9B,MAAM,oBAAoB,CAAC;AAU5B,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"}
+{"version":3,"file":"CryptoOps.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoOps.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,OAAO,EACP,kBAAkB,EAElB,MAAM,EAEN,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC9B,MAAM,oBAAoB,CAAC;AAU5B,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,UAAU,CAAC,EAAE,UAAU,EACvB,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,4 +1,4 @@
-/*! @azure/msal-browser v3.4.0 2023-10-30 */
+/*! @azure/msal-browser v3.5.1-beta.0 2023-11-14 */
 'use strict';
 import { PerformanceEvents, JoseHeader } from '@azure/msal-common';
 import { base64Encode, urlEncode, urlEncodeArr } from '../encode/Base64Encode.mjs';
@@ -8,149 +8,150 @@ import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { CryptoKeyStore } from '../cache/CryptoKeyStore.mjs';
 import { cryptoKeyNotFound } from '../error/BrowserAuthErrorCodes.mjs';
 
-/*
- * 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) {
-        this.logger = logger;
-        // Browser crypto needs to be validated first before any other classes can be set.
-        validateCryptoAvailable(logger);
-        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 createNewGuid();
-    }
-    /**
-     * Encodes input string to base64.
-     * @param input
-     */
-    base64Encode(input) {
-        return base64Encode(input);
-    }
-    /**
-     * Decodes input string from base64.
-     * @param input
-     */
-    base64Decode(input) {
-        return base64Decode(input);
-    }
-    /**
-     * 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 generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
-        // Generate Thumbprint for Public Key
-        const publicKeyJwk = await exportJwk(keyPair.publicKey);
-        const pubKeyThumprintObj = {
-            e: publicKeyJwk.e,
-            kty: publicKeyJwk.kty,
-            n: publicKeyJwk.n,
-        };
-        const publicJwkString = getSortedObjectString(pubKeyThumprintObj);
-        const publicJwkHash = await this.hashString(publicJwkString);
-        // Generate Thumbprint for Private Key
-        const privateKeyJwk = await exportJwk(keyPair.privateKey);
-        // Re-import private key to make it unextractable
-        const unextractablePrivateKey = await 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.end({
-                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 createBrowserAuthError(cryptoKeyNotFound);
-        }
-        // Get public key as JWK
-        const publicKeyJwk = await exportJwk(cachedKeyPair.publicKey);
-        const publicKeyJwkString = getSortedObjectString(publicKeyJwk);
-        // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
-        const encodedKeyIdThumbprint = urlEncode(JSON.stringify({ kid: kid }));
-        // Generate header
-        const shrHeader = JoseHeader.getShrHeaderString({
-            kid: encodedKeyIdThumbprint,
-            alg: publicKeyJwk.alg,
-        });
-        const encodedShrHeader = urlEncode(shrHeader);
-        // Generate payload
-        payload.cnf = {
-            jwk: JSON.parse(publicKeyJwkString),
-        };
-        const encodedPayload = urlEncode(JSON.stringify(payload));
-        // Form token string
-        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
-        // Sign token
-        const encoder = new TextEncoder();
-        const tokenBuffer = encoder.encode(tokenString);
-        const signatureBuffer = await sign(cachedKeyPair.privateKey, tokenBuffer);
-        const encodedSignature = urlEncodeArr(new Uint8Array(signatureBuffer));
-        const signedJwt = `${tokenString}.${encodedSignature}`;
-        if (signJwtMeasurement) {
-            signJwtMeasurement.end({
-                success: true,
-            });
-        }
-        return signedJwt;
-    }
-    /**
-     * Returns the SHA-256 hash of an input string
-     * @param plainText
-     */
-    async hashString(plainText) {
-        const hashBuffer = await sha256Digest(plainText);
-        const hashBytes = new Uint8Array(hashBuffer);
-        return urlEncodeArr(hashBytes);
-    }
-}
-CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
-CryptoOps.EXTRACTABLE = true;
-function getSortedObjectString(obj) {
-    return JSON.stringify(obj, Object.keys(obj).sort());
+/*
+ * 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) {
+        this.logger = logger;
+        // Browser crypto needs to be validated first before any other classes can be set.
+        validateCryptoAvailable(logger);
+        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 createNewGuid();
+    }
+    /**
+     * Encodes input string to base64.
+     * @param input
+     */
+    base64Encode(input) {
+        return base64Encode(input);
+    }
+    /**
+     * Decodes input string from base64.
+     * @param input
+     */
+    base64Decode(input) {
+        return base64Decode(input);
+    }
+    /**
+     * 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 generateKeyPair(CryptoOps.EXTRACTABLE, CryptoOps.POP_KEY_USAGES);
+        // Generate Thumbprint for Public Key
+        const publicKeyJwk = await exportJwk(keyPair.publicKey);
+        const pubKeyThumprintObj = {
+            e: publicKeyJwk.e,
+            kty: publicKeyJwk.kty,
+            n: publicKeyJwk.n,
+        };
+        const publicJwkString = getSortedObjectString(pubKeyThumprintObj);
+        const publicJwkHash = await this.hashString(publicJwkString);
+        // Generate Thumbprint for Private Key
+        const privateKeyJwk = await exportJwk(keyPair.privateKey);
+        // Re-import private key to make it unextractable
+        const unextractablePrivateKey = await 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.end({
+                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, shrOptions, correlationId) {
+        const signJwtMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.CryptoOptsSignJwt, correlationId);
+        const cachedKeyPair = await this.cache.asymmetricKeys.getItem(kid);
+        if (!cachedKeyPair) {
+            throw createBrowserAuthError(cryptoKeyNotFound);
+        }
+        // Get public key as JWK
+        const publicKeyJwk = await exportJwk(cachedKeyPair.publicKey);
+        const publicKeyJwkString = getSortedObjectString(publicKeyJwk);
+        // Base64URL encode public key thumbprint with keyId only: BASE64URL({ kid: "FULL_PUBLIC_KEY_HASH" })
+        const encodedKeyIdThumbprint = urlEncode(JSON.stringify({ kid: kid }));
+        // Generate header
+        const shrHeader = JoseHeader.getShrHeaderString({
+            ...shrOptions?.header,
+            alg: publicKeyJwk.alg,
+            kid: encodedKeyIdThumbprint,
+        });
+        const encodedShrHeader = urlEncode(shrHeader);
+        // Generate payload
+        payload.cnf = {
+            jwk: JSON.parse(publicKeyJwkString),
+        };
+        const encodedPayload = urlEncode(JSON.stringify(payload));
+        // Form token string
+        const tokenString = `${encodedShrHeader}.${encodedPayload}`;
+        // Sign token
+        const encoder = new TextEncoder();
+        const tokenBuffer = encoder.encode(tokenString);
+        const signatureBuffer = await sign(cachedKeyPair.privateKey, tokenBuffer);
+        const encodedSignature = urlEncodeArr(new Uint8Array(signatureBuffer));
+        const signedJwt = `${tokenString}.${encodedSignature}`;
+        if (signJwtMeasurement) {
+            signJwtMeasurement.end({
+                success: true,
+            });
+        }
+        return signedJwt;
+    }
+    /**
+     * Returns the SHA-256 hash of an input string
+     * @param plainText
+     */
+    async hashString(plainText) {
+        const hashBuffer = await sha256Digest(plainText);
+        const hashBytes = new Uint8Array(hashBuffer);
+        return urlEncodeArr(hashBytes);
+    }
+}
+CryptoOps.POP_KEY_USAGES = ["sign", "verify"];
+CryptoOps.EXTRACTABLE = true;
+function getSortedObjectString(obj) {
+    return JSON.stringify(obj, Object.keys(obj).sort());
 }
 
 export { CryptoOps };

package/dist/crypto/CryptoOps.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":["BrowserCrypto.validateCryptoAvailable","BrowserCrypto.createNewGuid","BrowserCrypto.generateKeyPair","BrowserCrypto.exportJwk"],"mappings":";;;;;;;;;;AAKA;AAkBA;;;AAUG;AACH;;AAGI;;;AAGG,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;AAGH,QAAAA,uBAAoE,CAAA,MAAA,CAAA,CAAA;AACpE,QAAA,IAAQ,CAAA,KAAM,GAAC,IAAA,cAA4B,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;QACpC,IAAC,kBAAsB,GAAA,iBAAA,CAAA;AAElB,KAAA;AAQZ;;;AAGG;AACH,IAAA,aAAa;AAIb,QAAA,OAAAC,aAAA,EAAA,CAAA;;;AAGG;AACH;AAIA;;;AAGG,KAAA;AACH;AAIA;;;AAGG,IAAA,YAAA,CAAA,KAAA,EAAA;QACyB,OAAA,YACxB,OAAO,CAAE;AAsDb,KAAA;;;AAGG;;AAOH,IAAA,MAAA,sBAAA,CAAA,OAAA,EAAA;;AAEG;AACG,QAAA,MAAA,OAAiB,GAAA,MAAQC,eAAQ,CAAA,SAAA,CAAA,WAAA,EAAA,SAAA,CAAA,cAAA,CAAA,CAAA;AAIvC;;;;AAIG,YAAA,GAAA,EAAA,YAAA,CAAA,GAAA;AACG,YACF,CAAO,EAAA,YAAmB,CAAA,CAAA;AA6D9B,SAAA,CAAA;;;AAGG;QACa,MAAA,aAAY,GAAA,MAAgBC,SAAQ,CAAA,OAAA,CAAA,UAAA,CAAA,CAAA;AAOvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"CryptoOps.mjs","sources":["../../src/crypto/CryptoOps.ts"],"sourcesContent":[null],"names":["BrowserCrypto.validateCryptoAvailable","BrowserCrypto.createNewGuid","BrowserCrypto.generateKeyPair","BrowserCrypto.exportJwk"],"mappings":";;;;;;;;;;AAKA;AAmBA;;;AAUG;AACH;;AAGI;;;AAGG,QAAA,IAAA,CAAA,MAAA,GAAA,MAAA,CAAA;;AAGH,QAAAA,uBAAoE,CAAA,MAAA,CAAA,CAAA;AACpE,QAAA,IAAQ,CAAA,KAAM,GAAC,IAAA,cAA4B,CAAA,IAAA,CAAA,MAAA,CAAA,CAAA;QACpC,IAAC,kBAAsB,GAAA,iBAAA,CAAA;AAElB,KAAA;AAQZ;;;AAGG;AACH,IAAA,aAAa;AAIb,QAAA,OAAAC,aAAA,EAAA,CAAA;;;AAGG;AACH;AAIA;;;AAGG,KAAA;AACH;AAIA;;;AAGG,IAAA,YAAA,CAAA,KAAA,EAAA;QACyB,OAAA,YACxB,OAAO,CAAE;AAsDb,KAAA;;;AAGG;;AAOH,IAAA,MAAA,sBAAA,CAAA,OAAA,EAAA;;AAEG;AACG,QAAA,MAAA,OAAiB,GAAA,MAAQC,eAAQ,CAAA,SAAA,CAAA,WAAA,EAAA,SAAA,CAAA,cAAA,CAAA,CAAA;AAIvC;;;;AAIG,YAAA,GAAA,EAAA,YAAA,CAAA,GAAA;YAEC,eAAS,CAAA,CAAA;AA8Db,SAAA,CAAA;;;AAGG;QACa,MAAA,aAAY,GAAA,MAAgBC,SAAQ,CAAA,OAAA,CAAA,UAAA,CAAA,CAAA;AAOvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/crypto/PkceGenerator.d.ts

@@ -1,9 +1,9 @@
-import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
-/**
- * This file defines APIs to generate PKCE codes and code verifiers.
- */
-/**
- * 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>;
+import { IPerformanceClient, Logger, PkceCodes } from "@azure/msal-common";
+/**
+ * This file defines APIs to generate PKCE codes and code verifiers.
+ */
+/**
+ * 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