@azure/msal-browser 3.0.2 → 3.2.0

package/src/telemetry/BrowserPerformanceMeasurement.ts

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IPerformanceMeasurement, SubMeasurement } from "@azure/msal-common";
+
+export class BrowserPerformanceMeasurement implements IPerformanceMeasurement {
+    private readonly measureName: string;
+    private readonly correlationId: string;
+    private readonly startMark: string;
+    private readonly endMark: string;
+
+    constructor(name: string, correlationId: string) {
+        this.correlationId = correlationId;
+        this.measureName = BrowserPerformanceMeasurement.makeMeasureName(
+            name,
+            correlationId
+        );
+        this.startMark = BrowserPerformanceMeasurement.makeStartMark(
+            name,
+            correlationId
+        );
+        this.endMark = BrowserPerformanceMeasurement.makeEndMark(
+            name,
+            correlationId
+        );
+    }
+
+    private static makeMeasureName(name: string, correlationId: string) {
+        return `msal.measure.${name}.${correlationId}`;
+    }
+
+    private static makeStartMark(name: string, correlationId: string) {
+        return `msal.start.${name}.${correlationId}`;
+    }
+
+    private static makeEndMark(name: string, correlationId: string) {
+        return `msal.end.${name}.${correlationId}`;
+    }
+
+    static supportsBrowserPerformance(): boolean {
+        return (
+            typeof window !== "undefined" &&
+            typeof window.performance !== "undefined" &&
+            typeof window.performance.mark === "function" &&
+            typeof window.performance.measure === "function" &&
+            typeof window.performance.clearMarks === "function" &&
+            typeof window.performance.clearMeasures === "function" &&
+            typeof window.performance.getEntriesByName === "function"
+        );
+    }
+
+    /**
+     * Flush browser marks and measurements.
+     * @param {string} correlationId
+     * @param {SubMeasurement} measurements
+     */
+    public static flushMeasurements(
+        correlationId: string,
+        measurements: SubMeasurement[]
+    ): void {
+        if (BrowserPerformanceMeasurement.supportsBrowserPerformance()) {
+            try {
+                measurements.forEach((measurement) => {
+                    const measureName =
+                        BrowserPerformanceMeasurement.makeMeasureName(
+                            measurement.name,
+                            correlationId
+                        );
+                    const entriesForMeasurement =
+                        window.performance.getEntriesByName(
+                            measureName,
+                            "measure"
+                        );
+                    if (entriesForMeasurement.length > 0) {
+                        window.performance.clearMeasures(measureName);
+                        window.performance.clearMarks(
+                            BrowserPerformanceMeasurement.makeStartMark(
+                                measureName,
+                                correlationId
+                            )
+                        );
+                        window.performance.clearMarks(
+                            BrowserPerformanceMeasurement.makeEndMark(
+                                measureName,
+                                correlationId
+                            )
+                        );
+                    }
+                });
+            } catch (e) {
+                // Silently catch and return null
+            }
+        }
+    }
+
+    startMeasurement(): void {
+        if (BrowserPerformanceMeasurement.supportsBrowserPerformance()) {
+            try {
+                window.performance.mark(this.startMark);
+            } catch (e) {
+                // Silently catch
+            }
+        }
+    }
+
+    endMeasurement(): void {
+        if (BrowserPerformanceMeasurement.supportsBrowserPerformance()) {
+            try {
+                window.performance.mark(this.endMark);
+                window.performance.measure(
+                    this.measureName,
+                    this.startMark,
+                    this.endMark
+                );
+            } catch (e) {
+                // Silently catch
+            }
+        }
+    }
+
+    flushMeasurement(): number | null {
+        if (BrowserPerformanceMeasurement.supportsBrowserPerformance()) {
+            try {
+                const entriesForMeasurement =
+                    window.performance.getEntriesByName(
+                        this.measureName,
+                        "measure"
+                    );
+                if (entriesForMeasurement.length > 0) {
+                    const durationMs = entriesForMeasurement[0].duration;
+                    window.performance.clearMeasures(this.measureName);
+                    window.performance.clearMarks(this.startMark);
+                    window.performance.clearMarks(this.endMark);
+                    return durationMs;
+                }
+            } catch (e) {
+                // Silently catch and return null
+            }
+        }
+        return null;
+    }
+}

package/src/utils/BrowserConstants.ts

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { OIDC_DEFAULT_SCOPES } from "@azure/msal-common";
+import { PopupRequest } from "../request/PopupRequest";
+import { RedirectRequest } from "../request/RedirectRequest";
+
+/**
+ * Constants
+ */
+export const BrowserConstants = {
+    /**
+     * Interaction in progress cache value
+     */
+    INTERACTION_IN_PROGRESS_VALUE: "interaction_in_progress",
+    /**
+     * Invalid grant error code
+     */
+    INVALID_GRANT_ERROR: "invalid_grant",
+    /**
+     * Default popup window width
+     */
+    POPUP_WIDTH: 483,
+    /**
+     * Default popup window height
+     */
+    POPUP_HEIGHT: 600,
+    /**
+     * Name of the popup window starts with
+     */
+    POPUP_NAME_PREFIX: "msal",
+    /**
+     * Default popup monitor poll interval in milliseconds
+     */
+    DEFAULT_POLL_INTERVAL_MS: 30,
+    /**
+     * Msal-browser SKU
+     */
+    MSAL_SKU: "msal.js.browser",
+};
+
+export const NativeConstants = {
+    CHANNEL_ID: "53ee284d-920a-4b59-9d30-a60315b26836",
+    PREFERRED_EXTENSION_ID: "ppnbnpeolgkicgegkbkbjmhlideopiji",
+    MATS_TELEMETRY: "MATS",
+};
+
+export const NativeExtensionMethod = {
+    HandshakeRequest: "Handshake",
+    HandshakeResponse: "HandshakeResponse",
+    GetToken: "GetToken",
+    Response: "Response",
+} as const;
+export type NativeExtensionMethod =
+    (typeof NativeExtensionMethod)[keyof typeof NativeExtensionMethod];
+
+export const BrowserCacheLocation = {
+    LocalStorage: "localStorage",
+    SessionStorage: "sessionStorage",
+    MemoryStorage: "memoryStorage",
+} as const;
+export type BrowserCacheLocation =
+    (typeof BrowserCacheLocation)[keyof typeof BrowserCacheLocation];
+
+/**
+ * HTTP Request types supported by MSAL.
+ */
+export const HTTP_REQUEST_TYPE = {
+    GET: "GET",
+    POST: "POST",
+} as const;
+export type HTTP_REQUEST_TYPE =
+    (typeof HTTP_REQUEST_TYPE)[keyof typeof HTTP_REQUEST_TYPE];
+
+/**
+ * Temporary cache keys for MSAL, deleted after any request.
+ */
+export const TemporaryCacheKeys = {
+    AUTHORITY: "authority",
+    ACQUIRE_TOKEN_ACCOUNT: "acquireToken.account",
+    SESSION_STATE: "session.state",
+    REQUEST_STATE: "request.state",
+    NONCE_IDTOKEN: "nonce.id_token",
+    ORIGIN_URI: "request.origin",
+    RENEW_STATUS: "token.renew.status",
+    URL_HASH: "urlHash",
+    REQUEST_PARAMS: "request.params",
+    SCOPES: "scopes",
+    INTERACTION_STATUS_KEY: "interaction.status",
+    CCS_CREDENTIAL: "ccs.credential",
+    CORRELATION_ID: "request.correlationId",
+    NATIVE_REQUEST: "request.native",
+    REDIRECT_CONTEXT: "request.redirect.context",
+} as const;
+export type TemporaryCacheKeys =
+    (typeof TemporaryCacheKeys)[keyof typeof TemporaryCacheKeys];
+
+export const StaticCacheKeys = {
+    ACCOUNT_KEYS: "msal.account.keys",
+    TOKEN_KEYS: "msal.token.keys",
+} as const;
+export type StaticCacheKeys =
+    (typeof StaticCacheKeys)[keyof typeof StaticCacheKeys];
+
+/**
+ * Cache keys stored in-memory
+ */
+export const InMemoryCacheKeys = {
+    WRAPPER_SKU: "wrapper.sku",
+    WRAPPER_VER: "wrapper.version",
+} as const;
+export type InMemoryCacheKeys =
+    (typeof InMemoryCacheKeys)[keyof typeof InMemoryCacheKeys];
+
+/**
+ * API Codes for Telemetry purposes.
+ * Before adding a new code you must claim it in the MSAL Telemetry tracker as these number spaces are shared across all MSALs
+ * 0-99 Silent Flow
+ * 800-899 Auth Code Flow
+ */
+export const ApiId = {
+    acquireTokenRedirect: 861,
+    acquireTokenPopup: 862,
+    ssoSilent: 863,
+    acquireTokenSilent_authCode: 864,
+    handleRedirectPromise: 865,
+    acquireTokenByCode: 866,
+    acquireTokenSilent_silentFlow: 61,
+    logout: 961,
+    logoutPopup: 962,
+} as const;
+export type ApiId = (typeof ApiId)[keyof typeof ApiId];
+
+/*
+ * Interaction type of the API - used for state and telemetry
+ */
+export enum InteractionType {
+    Redirect = "redirect",
+    Popup = "popup",
+    Silent = "silent",
+    None = "none",
+}
+
+/**
+ * Types of interaction currently in progress.
+ * Used in events in wrapper libraries to invoke functions when certain interaction is in progress or all interactions are complete.
+ */
+export const InteractionStatus = {
+    /**
+     * Initial status before interaction occurs
+     */
+    Startup: "startup",
+    /**
+     * Status set when all login calls occuring
+     */
+    Login: "login",
+    /**
+     * Status set when logout call occuring
+     */
+    Logout: "logout",
+    /**
+     * Status set for acquireToken calls
+     */
+    AcquireToken: "acquireToken",
+    /**
+     * Status set for ssoSilent calls
+     */
+    SsoSilent: "ssoSilent",
+    /**
+     * Status set when handleRedirect in progress
+     */
+    HandleRedirect: "handleRedirect",
+    /**
+     * Status set when interaction is complete
+     */
+    None: "none",
+} as const;
+export type InteractionStatus =
+    (typeof InteractionStatus)[keyof typeof InteractionStatus];
+
+export const DEFAULT_REQUEST: RedirectRequest | PopupRequest = {
+    scopes: OIDC_DEFAULT_SCOPES,
+};
+
+/**
+ * JWK Key Format string (Type MUST be defined for window crypto APIs)
+ */
+export const KEY_FORMAT_JWK = "jwk";
+
+// Supported wrapper SKUs
+export const WrapperSKU = {
+    React: "@azure/msal-react",
+    Angular: "@azure/msal-angular",
+} as const;
+export type WrapperSKU = (typeof WrapperSKU)[keyof typeof WrapperSKU];
+
+// DatabaseStorage Constants
+export const DB_NAME = "msal.db";
+export const DB_VERSION = 1;
+export const DB_TABLE_NAME = `${DB_NAME}.keys`;
+
+export const CacheLookupPolicy = {
+    /*
+     * acquireTokenSilent will attempt to retrieve an access token from the cache. If the access token is expired
+     * or cannot be found the refresh token will be used to acquire a new one. Finally, if the refresh token
+     * is expired acquireTokenSilent will attempt to acquire new access and refresh tokens.
+     */
+    Default: 0, // 0 is falsy, is equivalent to not passing in a CacheLookupPolicy
+    /*
+     * acquireTokenSilent will only look for access tokens in the cache. It will not attempt to renew access or
+     * refresh tokens.
+     */
+    AccessToken: 1,
+    /*
+     * acquireTokenSilent will attempt to retrieve an access token from the cache. If the access token is expired or
+     * cannot be found, the refresh token will be used to acquire a new one. If the refresh token is expired, it
+     * will not be renewed and acquireTokenSilent will fail.
+     */
+    AccessTokenAndRefreshToken: 2,
+    /*
+     * acquireTokenSilent will not attempt to retrieve access tokens from the cache and will instead attempt to
+     * exchange the cached refresh token for a new access token. If the refresh token is expired, it will not be
+     * renewed and acquireTokenSilent will fail.
+     */
+    RefreshToken: 3,
+    /*
+     * acquireTokenSilent will not look in the cache for the access token. It will go directly to network with the
+     * cached refresh token. If the refresh token is expired an attempt will be made to renew it. This is equivalent to
+     * setting "forceRefresh: true".
+     */
+    RefreshTokenAndNetwork: 4,
+    /*
+     * acquireTokenSilent will attempt to renew both access and refresh tokens. It will not look in the cache. This will
+     * always fail if 3rd party cookies are blocked by the browser.
+     */
+    Skip: 5,
+} as const;
+export type CacheLookupPolicy =
+    (typeof CacheLookupPolicy)[keyof typeof CacheLookupPolicy];

package/src/utils/BrowserProtocolUtils.ts

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { InteractionType } from "./BrowserConstants";
+import {
+    ICrypto,
+    RequestStateObject,
+    ProtocolUtils,
+    ServerAuthorizationCodeResponse,
+    UrlString,
+    createClientAuthError,
+    ClientAuthErrorCodes,
+} from "@azure/msal-common";
+
+export type BrowserStateObject = {
+    interactionType: InteractionType;
+};
+
+export class BrowserProtocolUtils {
+    /**
+     * Extracts the BrowserStateObject from the state string.
+     * @param browserCrypto
+     * @param state
+     */
+    static extractBrowserRequestState(
+        browserCrypto: ICrypto,
+        state: string
+    ): BrowserStateObject | null {
+        if (!state) {
+            return null;
+        }
+
+        try {
+            const requestStateObj: RequestStateObject =
+                ProtocolUtils.parseRequestState(browserCrypto, state);
+            return requestStateObj.libraryState.meta as BrowserStateObject;
+        } catch (e) {
+            throw createClientAuthError(ClientAuthErrorCodes.invalidState);
+        }
+    }
+
+    /**
+     * Parses properties of server response from url hash
+     * @param locationHash Hash from url
+     */
+    static parseServerResponseFromHash(
+        locationHash: string
+    ): ServerAuthorizationCodeResponse {
+        if (!locationHash) {
+            return {};
+        }
+
+        const hashUrlString = new UrlString(locationHash);
+        return UrlString.getDeserializedHash(hashUrlString.getHash());
+    }
+}

package/src/utils/BrowserStringUtils.ts

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Constants } from "@azure/msal-common";
+
+/**
+ * Utility functions for strings in a browser. See here for implementation details:
+ * https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Solution_2_%E2%80%93_JavaScript's_UTF-16_%3E_UTF-8_%3E_base64
+ */
+export class BrowserStringUtils {
+    /**
+     * Converts string to Uint8Array
+     * @param sDOMStr
+     */
+    static stringToUtf8Arr(sDOMStr: string): Uint8Array {
+        let nChr;
+        let nArrLen = 0;
+        const nStrLen = sDOMStr.length;
+        /* mapping... */
+        for (let nMapIdx = 0; nMapIdx < nStrLen; nMapIdx++) {
+            nChr = sDOMStr.charCodeAt(nMapIdx);
+            nArrLen +=
+                nChr < 0x80
+                    ? 1
+                    : nChr < 0x800
+                    ? 2
+                    : nChr < 0x10000
+                    ? 3
+                    : nChr < 0x200000
+                    ? 4
+                    : nChr < 0x4000000
+                    ? 5
+                    : 6;
+        }
+
+        const aBytes = new Uint8Array(nArrLen);
+
+        /* transcription... */
+
+        for (let nIdx = 0, nChrIdx = 0; nIdx < nArrLen; nChrIdx++) {
+            nChr = sDOMStr.charCodeAt(nChrIdx);
+            if (nChr < 128) {
+                /* one byte */
+                aBytes[nIdx++] = nChr;
+            } else if (nChr < 0x800) {
+                /* two bytes */
+                aBytes[nIdx++] = 192 + (nChr >>> 6);
+                aBytes[nIdx++] = 128 + (nChr & 63);
+            } else if (nChr < 0x10000) {
+                /* three bytes */
+                aBytes[nIdx++] = 224 + (nChr >>> 12);
+                aBytes[nIdx++] = 128 + ((nChr >>> 6) & 63);
+                aBytes[nIdx++] = 128 + (nChr & 63);
+            } else if (nChr < 0x200000) {
+                /* four bytes */
+                aBytes[nIdx++] = 240 + (nChr >>> 18);
+                aBytes[nIdx++] = 128 + ((nChr >>> 12) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 6) & 63);
+                aBytes[nIdx++] = 128 + (nChr & 63);
+            } else if (nChr < 0x4000000) {
+                /* five bytes */
+                aBytes[nIdx++] = 248 + (nChr >>> 24);
+                aBytes[nIdx++] = 128 + ((nChr >>> 18) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 12) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 6) & 63);
+                aBytes[nIdx++] = 128 + (nChr & 63);
+            } /* if (nChr <= 0x7fffffff) */ else {
+                /* six bytes */
+                aBytes[nIdx++] = 252 + (nChr >>> 30);
+                aBytes[nIdx++] = 128 + ((nChr >>> 24) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 18) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 12) & 63);
+                aBytes[nIdx++] = 128 + ((nChr >>> 6) & 63);
+                aBytes[nIdx++] = 128 + (nChr & 63);
+            }
+        }
+
+        return aBytes;
+    }
+
+    /**
+     * Converts Uint8Array to a string
+     * @param aBytes
+     */
+    static utf8ArrToString(aBytes: Uint8Array): string {
+        let sView = Constants.EMPTY_STRING;
+        for (let nPart, nLen = aBytes.length, nIdx = 0; nIdx < nLen; nIdx++) {
+            nPart = aBytes[nIdx];
+            sView += String.fromCharCode(
+                nPart > 251 && nPart < 254 && nIdx + 5 < nLen /* six bytes */
+                    ? /* (nPart - 252 << 30) may be not so safe in ECMAScript! So...: */
+                      (nPart - 252) * 1073741824 +
+                          ((aBytes[++nIdx] - 128) << 24) +
+                          ((aBytes[++nIdx] - 128) << 18) +
+                          ((aBytes[++nIdx] - 128) << 12) +
+                          ((aBytes[++nIdx] - 128) << 6) +
+                          aBytes[++nIdx] -
+                          128
+                    : nPart > 247 &&
+                      nPart < 252 &&
+                      nIdx + 4 < nLen /* five bytes */
+                    ? ((nPart - 248) << 24) +
+                      ((aBytes[++nIdx] - 128) << 18) +
+                      ((aBytes[++nIdx] - 128) << 12) +
+                      ((aBytes[++nIdx] - 128) << 6) +
+                      aBytes[++nIdx] -
+                      128
+                    : nPart > 239 &&
+                      nPart < 248 &&
+                      nIdx + 3 < nLen /* four bytes */
+                    ? ((nPart - 240) << 18) +
+                      ((aBytes[++nIdx] - 128) << 12) +
+                      ((aBytes[++nIdx] - 128) << 6) +
+                      aBytes[++nIdx] -
+                      128
+                    : nPart > 223 &&
+                      nPart < 240 &&
+                      nIdx + 2 < nLen /* three bytes */
+                    ? ((nPart - 224) << 12) +
+                      ((aBytes[++nIdx] - 128) << 6) +
+                      aBytes[++nIdx] -
+                      128
+                    : nPart > 191 &&
+                      nPart < 224 &&
+                      nIdx + 1 < nLen /* two bytes */
+                    ? ((nPart - 192) << 6) + aBytes[++nIdx] - 128
+                    : /* nPart < 127 ? */ /* one byte */
+                      nPart
+            );
+        }
+        return sView;
+    }
+
+    /**
+     * Returns stringified jwk.
+     * @param jwk
+     */
+    static getSortedObjectString(obj: object): string {
+        return JSON.stringify(obj, Object.keys(obj).sort());
+    }
+}