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

package/dist/crypto/BrowserCrypto.d.ts

@@ -1,62 +1,62 @@
-import { Logger } from "@azure/msal-common";
-import { CryptoOptions } from "../config/Configuration";
-/**
- * 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;
-    private cryptoOptions?;
-    constructor(logger: Logger, cryptoOptions?: CryptoOptions);
-    /**
-     * Check whether IE crypto or other browser cryptography is available.
-     */
-    private hasIECrypto;
-    /**
-     * Check whether browser crypto is available.
-     */
-    private hasBrowserCrypto;
-    /**
-     * Check whether MSR crypto polyfill is available
-     */
-    private hasMsrCrypto;
-    /**
-     * 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
-     * @param format
-     */
-    exportJwk(key: CryptoKey): Promise<JsonWebKey>;
-    /**
-     * Imports key as Json Web Key (JWK), can set extractable and usages.
-     * @param key
-     * @param format
-     * @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 { Logger } from "@azure/msal-common";
+import { CryptoOptions } from "../config/Configuration";
+/**
+ * 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;
+    private cryptoOptions?;
+    constructor(logger: Logger, cryptoOptions?: CryptoOptions);
+    /**
+     * Check whether IE crypto or other browser cryptography is available.
+     */
+    private hasIECrypto;
+    /**
+     * Check whether browser crypto is available.
+     */
+    private hasBrowserCrypto;
+    /**
+     * Check whether MSR crypto polyfill is available
+     */
+    private hasMsrCrypto;
+    /**
+     * 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
+     * @param format
+     */
+    exportJwk(key: CryptoKey): Promise<JsonWebKey>;
+    /**
+     * Imports key as Json Web Key (JWK), can set extractable and usages.
+     * @param key
+     * @param format
+     * @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>;
+}
 //# sourceMappingURL=BrowserCrypto.d.ts.map

package/dist/crypto/BrowserCrypto.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 { BrowserStringUtils } from '../utils/BrowserStringUtils.js';
 import { BrowserAuthError } from '../error/BrowserAuthError.js';
@@ -7,136 +7,136 @@ import { MsrBrowserCrypto } from './MsrBrowserCrypto.js';
 import { MsBrowserCrypto } from './MsBrowserCrypto.js';
 import { BrowserConfigurationAuthError } from '../error/BrowserConfigurationAuthError.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * 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]);
-/**
- * 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.
- */
-class BrowserCrypto {
-    constructor(logger, cryptoOptions) {
-        this.logger = logger;
-        this.cryptoOptions = cryptoOptions;
-        if (this.hasBrowserCrypto()) {
-            // Use standard modern web crypto if available
-            this.logger.verbose("BrowserCrypto: modern crypto interface available");
-            this.subtleCrypto = new ModernBrowserCrypto();
-        }
-        else if (this.hasIECrypto()) {
-            // For IE11, use msCrypto interface
-            this.logger.verbose("BrowserCrypto: MS crypto interface available");
-            this.subtleCrypto = new MsBrowserCrypto();
-        }
-        else if (this.hasMsrCrypto() && this.cryptoOptions?.useMsrCrypto) {
-            // For other browsers, use MSR Crypto if found
-            this.logger.verbose("BrowserCrypto: MSR crypto interface available");
-            this.subtleCrypto = new MsrBrowserCrypto();
-        }
-        else {
-            if (this.hasMsrCrypto()) {
-                this.logger.info("BrowserCrypto: MSR Crypto interface available but system.cryptoOptions.useMsrCrypto not enabled");
-            }
-            this.logger.error("BrowserCrypto: No crypto interfaces available.");
-            throw BrowserAuthError.createCryptoNotAvailableError("Browser crypto, msCrypto, or msrCrypto interfaces not available.");
-        }
-        // Mainly needed for MSR Crypto: https://github.com/microsoft/MSR-JavaScript-Crypto#random-number-generator-prng
-        if (this.subtleCrypto.initPrng) {
-            this.logger.verbose("BrowserCrypto: Interface requires entropy");
-            if (!this.cryptoOptions?.entropy) {
-                this.logger.error("BrowserCrypto: Interface requires entropy but none provided.");
-                throw BrowserConfigurationAuthError.createEntropyNotProvided();
-            }
-            this.logger.verbose("BrowserCrypto: Entropy provided");
-            this.subtleCrypto.initPrng(this.cryptoOptions.entropy);
-        }
-        this.keygenAlgorithmOptions = {
-            name: PKCS1_V15_KEYGEN_ALG,
-            hash: S256_HASH_ALG,
-            modulusLength: MODULUS_LENGTH,
-            publicExponent: PUBLIC_EXPONENT,
-        };
-    }
-    /**
-     * Check whether IE crypto or other browser cryptography is available.
-     */
-    hasIECrypto() {
-        return "msCrypto" in window;
-    }
-    /**
-     * Check whether browser crypto is available.
-     */
-    hasBrowserCrypto() {
-        return "crypto" in window;
-    }
-    /**
-     * Check whether MSR crypto polyfill is available
-     */
-    hasMsrCrypto() {
-        return "msrCrypto" 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);
-    }
-    /**
-     * Export key as Json Web Key (JWK)
-     * @param key
-     * @param format
-     */
-    async exportJwk(key) {
-        return this.subtleCrypto.exportKey(key);
-    }
-    /**
-     * Imports key as Json Web Key (JWK), can set extractable and usages.
-     * @param key
-     * @param format
-     * @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);
-    }
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * 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]);
+/**
+ * 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.
+ */
+class BrowserCrypto {
+    constructor(logger, cryptoOptions) {
+        this.logger = logger;
+        this.cryptoOptions = cryptoOptions;
+        if (this.hasBrowserCrypto()) {
+            // Use standard modern web crypto if available
+            this.logger.verbose("BrowserCrypto: modern crypto interface available");
+            this.subtleCrypto = new ModernBrowserCrypto();
+        }
+        else if (this.hasIECrypto()) {
+            // For IE11, use msCrypto interface
+            this.logger.verbose("BrowserCrypto: MS crypto interface available");
+            this.subtleCrypto = new MsBrowserCrypto();
+        }
+        else if (this.hasMsrCrypto() && this.cryptoOptions?.useMsrCrypto) {
+            // For other browsers, use MSR Crypto if found
+            this.logger.verbose("BrowserCrypto: MSR crypto interface available");
+            this.subtleCrypto = new MsrBrowserCrypto();
+        }
+        else {
+            if (this.hasMsrCrypto()) {
+                this.logger.info("BrowserCrypto: MSR Crypto interface available but system.cryptoOptions.useMsrCrypto not enabled");
+            }
+            this.logger.error("BrowserCrypto: No crypto interfaces available.");
+            throw BrowserAuthError.createCryptoNotAvailableError("Browser crypto, msCrypto, or msrCrypto interfaces not available.");
+        }
+        // Mainly needed for MSR Crypto: https://github.com/microsoft/MSR-JavaScript-Crypto#random-number-generator-prng
+        if (this.subtleCrypto.initPrng) {
+            this.logger.verbose("BrowserCrypto: Interface requires entropy");
+            if (!this.cryptoOptions?.entropy) {
+                this.logger.error("BrowserCrypto: Interface requires entropy but none provided.");
+                throw BrowserConfigurationAuthError.createEntropyNotProvided();
+            }
+            this.logger.verbose("BrowserCrypto: Entropy provided");
+            this.subtleCrypto.initPrng(this.cryptoOptions.entropy);
+        }
+        this.keygenAlgorithmOptions = {
+            name: PKCS1_V15_KEYGEN_ALG,
+            hash: S256_HASH_ALG,
+            modulusLength: MODULUS_LENGTH,
+            publicExponent: PUBLIC_EXPONENT,
+        };
+    }
+    /**
+     * Check whether IE crypto or other browser cryptography is available.
+     */
+    hasIECrypto() {
+        return "msCrypto" in window;
+    }
+    /**
+     * Check whether browser crypto is available.
+     */
+    hasBrowserCrypto() {
+        return "crypto" in window;
+    }
+    /**
+     * Check whether MSR crypto polyfill is available
+     */
+    hasMsrCrypto() {
+        return "msrCrypto" 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);
+    }
+    /**
+     * Export key as Json Web Key (JWK)
+     * @param key
+     * @param format
+     */
+    async exportJwk(key) {
+        return this.subtleCrypto.exportKey(key);
+    }
+    /**
+     * Imports key as Json Web Key (JWK), can set extractable and usages.
+     * @param key
+     * @param format
+     * @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);
+    }
 }
 
 export { BrowserCrypto };

package/dist/crypto/CryptoOps.d.ts

@@ -1,74 +1,74 @@
-import { ICrypto, IPerformanceClient, Logger, PkceCodes, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
-import { CryptoOptions } from "../config/Configuration";
-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 browserCrypto;
-    private guidGenerator;
-    private b64Encode;
-    private b64Decode;
-    private pkceGenerator;
-    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, cryptoConfig?: CryptoOptions);
-    /**
-     * 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 PKCE codes used in Authorization Code Flow.
-     */
-    generatePkceCodes(): Promise<PkceCodes>;
-    /**
-     * 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, PkceCodes, SignedHttpRequest, SignedHttpRequestParameters } from "@azure/msal-common";
+import { CryptoOptions } from "../config/Configuration";
+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 browserCrypto;
+    private guidGenerator;
+    private b64Encode;
+    private b64Decode;
+    private pkceGenerator;
+    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, cryptoConfig?: CryptoOptions);
+    /**
+     * 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 PKCE codes used in Authorization Code Flow.
+     */
+    generatePkceCodes(): Promise<PkceCodes>;
+    /**
+     * 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>;
+}
 //# sourceMappingURL=CryptoOps.d.ts.map