@azure/msal-browser 3.0.1 → 3.1.0

package/src/cache/BrowserStorage.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { BrowserConfigurationAuthError } from "../error/BrowserConfigurationAuthError";
+import { BrowserCacheLocation } from "../utils/BrowserConstants";
+import { IWindowStorage } from "./IWindowStorage";
+
+export class BrowserStorage implements IWindowStorage<string> {
+    private windowStorage: Storage;
+
+    constructor(cacheLocation: string) {
+        this.validateWindowStorage(cacheLocation);
+        this.windowStorage = window[cacheLocation];
+    }
+
+    private validateWindowStorage(cacheLocation: string): void {
+        if (
+            cacheLocation !== BrowserCacheLocation.LocalStorage &&
+            cacheLocation !== BrowserCacheLocation.SessionStorage
+        ) {
+            throw BrowserConfigurationAuthError.createStorageNotSupportedError(
+                cacheLocation
+            );
+        }
+        const storageSupported = !!window[cacheLocation];
+        if (!storageSupported) {
+            throw BrowserConfigurationAuthError.createStorageNotSupportedError(
+                cacheLocation
+            );
+        }
+    }
+
+    getItem(key: string): string | null {
+        return this.windowStorage.getItem(key);
+    }
+
+    setItem(key: string, value: string): void {
+        this.windowStorage.setItem(key, value);
+    }
+
+    removeItem(key: string): void {
+        this.windowStorage.removeItem(key);
+    }
+
+    getKeys(): string[] {
+        return Object.keys(this.windowStorage);
+    }
+
+    containsKey(key: string): boolean {
+        return this.windowStorage.hasOwnProperty(key);
+    }
+}

package/src/cache/CryptoKeyStore.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Logger } from "@azure/msal-common";
+import { CachedKeyPair } from "../crypto/CryptoOps";
+import { AsyncMemoryStorage } from "./AsyncMemoryStorage";
+
+export const CryptoKeyStoreNames = {
+    asymmetricKeys: "asymmetricKeys",
+    symmetricKeys: "symmetricKeys",
+} as const;
+export type CryptoKeyStoreNames =
+    (typeof CryptoKeyStoreNames)[keyof typeof CryptoKeyStoreNames];
+
+/**
+ * MSAL CryptoKeyStore DB Version 2
+ */
+export class CryptoKeyStore {
+    public asymmetricKeys: AsyncMemoryStorage<CachedKeyPair>;
+    public symmetricKeys: AsyncMemoryStorage<CryptoKey>;
+    public logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+        this.asymmetricKeys = new AsyncMemoryStorage<CachedKeyPair>(
+            this.logger,
+            CryptoKeyStoreNames.asymmetricKeys
+        );
+        this.symmetricKeys = new AsyncMemoryStorage<CryptoKey>(
+            this.logger,
+            CryptoKeyStoreNames.symmetricKeys
+        );
+    }
+
+    async clear(): Promise<boolean> {
+        // Delete in-memory keystores
+        this.asymmetricKeys.clearInMemory();
+        this.symmetricKeys.clearInMemory();
+
+        /**
+         * There is only one database, so calling clearPersistent on asymmetric keystore takes care of
+         * every persistent keystore
+         */
+        try {
+            await this.asymmetricKeys.clearPersistent();
+            return true;
+        } catch (e) {
+            if (e instanceof Error) {
+                this.logger.error(
+                    `Clearing keystore failed with error: ${e.message}`
+                );
+            } else {
+                this.logger.error(
+                    "Clearing keystore failed with unknown error"
+                );
+            }
+
+            return false;
+        }
+    }
+}

package/src/cache/DatabaseStorage.ts

@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    createBrowserAuthError,
+    BrowserAuthErrorCodes,
+} from "../error/BrowserAuthError";
+import { DB_NAME, DB_TABLE_NAME, DB_VERSION } from "../utils/BrowserConstants";
+import { IAsyncStorage } from "./IAsyncMemoryStorage";
+
+interface IDBOpenDBRequestEvent extends Event {
+    target: IDBOpenDBRequest & EventTarget;
+}
+
+interface IDBOpenOnUpgradeNeededEvent extends IDBVersionChangeEvent {
+    target: IDBOpenDBRequest & EventTarget;
+}
+
+interface IDBRequestEvent extends Event {
+    target: IDBRequest & EventTarget;
+}
+
+/**
+ * Storage wrapper for IndexedDB storage in browsers: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API
+ */
+export class DatabaseStorage<T> implements IAsyncStorage<T> {
+    private db: IDBDatabase | undefined;
+    private dbName: string;
+    private tableName: string;
+    private version: number;
+    private dbOpen: boolean;
+
+    constructor() {
+        this.dbName = DB_NAME;
+        this.version = DB_VERSION;
+        this.tableName = DB_TABLE_NAME;
+        this.dbOpen = false;
+    }
+
+    /**
+     * Opens IndexedDB instance.
+     */
+    async open(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const openDB = window.indexedDB.open(this.dbName, this.version);
+            openDB.addEventListener(
+                "upgradeneeded",
+                (e: IDBVersionChangeEvent) => {
+                    const event = e as IDBOpenOnUpgradeNeededEvent;
+                    event.target.result.createObjectStore(this.tableName);
+                }
+            );
+            openDB.addEventListener("success", (e: Event) => {
+                const event = e as IDBOpenDBRequestEvent;
+                this.db = event.target.result;
+                this.dbOpen = true;
+                resolve();
+            });
+            openDB.addEventListener("error", () =>
+                reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseUnavailable
+                    )
+                )
+            );
+        });
+    }
+
+    /**
+     * Closes the connection to IndexedDB database when all pending transactions
+     * complete.
+     */
+    closeConnection(): void {
+        const db = this.db;
+        if (db && this.dbOpen) {
+            db.close();
+            this.dbOpen = false;
+        }
+    }
+
+    /**
+     * Opens database if it's not already open
+     */
+    private async validateDbIsOpen(): Promise<void> {
+        if (!this.dbOpen) {
+            return await this.open();
+        }
+    }
+
+    /**
+     * Retrieves item from IndexedDB instance.
+     * @param key
+     */
+    async getItem(key: string): Promise<T | null> {
+        await this.validateDbIsOpen();
+        return new Promise<T>((resolve, reject) => {
+            // TODO: Add timeouts?
+            if (!this.db) {
+                return reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseNotOpen
+                    )
+                );
+            }
+            const transaction = this.db.transaction(
+                [this.tableName],
+                "readonly"
+            );
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbGet = objectStore.get(key);
+
+            dbGet.addEventListener("success", (e: Event) => {
+                const event = e as IDBRequestEvent;
+                this.closeConnection();
+                resolve(event.target.result);
+            });
+
+            dbGet.addEventListener("error", (e: Event) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+
+    /**
+     * Adds item to IndexedDB under given key
+     * @param key
+     * @param payload
+     */
+    async setItem(key: string, payload: T): Promise<void> {
+        await this.validateDbIsOpen();
+        return new Promise<void>((resolve: Function, reject: Function) => {
+            // TODO: Add timeouts?
+            if (!this.db) {
+                return reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseNotOpen
+                    )
+                );
+            }
+            const transaction = this.db.transaction(
+                [this.tableName],
+                "readwrite"
+            );
+
+            const objectStore = transaction.objectStore(this.tableName);
+
+            const dbPut = objectStore.put(payload, key);
+
+            dbPut.addEventListener("success", () => {
+                this.closeConnection();
+                resolve();
+            });
+
+            dbPut.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+
+    /**
+     * Removes item from IndexedDB under given key
+     * @param key
+     */
+    async removeItem(key: string): Promise<void> {
+        await this.validateDbIsOpen();
+        return new Promise<void>((resolve: Function, reject: Function) => {
+            if (!this.db) {
+                return reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseNotOpen
+                    )
+                );
+            }
+
+            const transaction = this.db.transaction(
+                [this.tableName],
+                "readwrite"
+            );
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbDelete = objectStore.delete(key);
+
+            dbDelete.addEventListener("success", () => {
+                this.closeConnection();
+                resolve();
+            });
+
+            dbDelete.addEventListener("error", (e) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+
+    /**
+     * Get all the keys from the storage object as an iterable array of strings.
+     */
+    async getKeys(): Promise<string[]> {
+        await this.validateDbIsOpen();
+        return new Promise<string[]>((resolve: Function, reject: Function) => {
+            if (!this.db) {
+                return reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseNotOpen
+                    )
+                );
+            }
+
+            const transaction = this.db.transaction(
+                [this.tableName],
+                "readonly"
+            );
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbGetKeys = objectStore.getAllKeys();
+
+            dbGetKeys.addEventListener("success", (e: Event) => {
+                const event = e as IDBRequestEvent;
+                this.closeConnection();
+                resolve(event.target.result);
+            });
+
+            dbGetKeys.addEventListener("error", (e: Event) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+
+    /**
+     *
+     * Checks whether there is an object under the search key in the object store
+     */
+    async containsKey(key: string): Promise<boolean> {
+        await this.validateDbIsOpen();
+
+        return new Promise<boolean>((resolve: Function, reject: Function) => {
+            if (!this.db) {
+                return reject(
+                    createBrowserAuthError(
+                        BrowserAuthErrorCodes.databaseNotOpen
+                    )
+                );
+            }
+
+            const transaction = this.db.transaction(
+                [this.tableName],
+                "readonly"
+            );
+            const objectStore = transaction.objectStore(this.tableName);
+            const dbContainsKey = objectStore.count(key);
+
+            dbContainsKey.addEventListener("success", (e: Event) => {
+                const event = e as IDBRequestEvent;
+                this.closeConnection();
+                resolve(event.target.result === 1);
+            });
+
+            dbContainsKey.addEventListener("error", (e: Event) => {
+                this.closeConnection();
+                reject(e);
+            });
+        });
+    }
+
+    /**
+     * Deletes the MSAL database. The database is deleted rather than cleared to make it possible
+     * for client applications to downgrade to a previous MSAL version without worrying about forward compatibility issues
+     * with IndexedDB database versions.
+     */
+    async deleteDatabase(): Promise<boolean> {
+        // Check if database being deleted exists
+
+        if (this.db && this.dbOpen) {
+            this.closeConnection();
+        }
+
+        return new Promise<boolean>((resolve: Function, reject: Function) => {
+            const deleteDbRequest = window.indexedDB.deleteDatabase(DB_NAME);
+            deleteDbRequest.addEventListener("success", () => resolve(true));
+            deleteDbRequest.addEventListener("blocked", () => resolve(true));
+            deleteDbRequest.addEventListener("error", () => reject(false));
+        });
+    }
+}

package/src/cache/IAsyncMemoryStorage.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export interface IAsyncStorage<T> {
+    /**
+     * Get the item from the asynchronous storage object matching the given key.
+     * @param key
+     */
+    getItem(key: string): Promise<T | null>;
+
+    /**
+     * Sets the item in the asynchronous storage object with the given key.
+     * @param key
+     * @param value
+     */
+    setItem(key: string, value: T): Promise<void>;
+
+    /**
+     * Removes the item in the asynchronous storage object matching the given key.
+     * @param key
+     */
+    removeItem(key: string): Promise<void>;
+
+    /**
+     * Get all the keys from the asynchronous storage object as an iterable array of strings.
+     */
+    getKeys(): Promise<string[]>;
+
+    /**
+     * Returns true or false if the given key is present in the cache.
+     * @param key
+     */
+    containsKey(key: string): Promise<boolean>;
+}

package/src/cache/ITokenCache.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ExternalTokenResponse } from "@azure/msal-common";
+import { SilentRequest } from "../request/SilentRequest";
+import { LoadTokenOptions } from "./TokenCache";
+import { AuthenticationResult } from "../response/AuthenticationResult";
+
+export interface ITokenCache {
+    /**
+     * API to side-load tokens to MSAL cache
+     * @returns `AuthenticationResult` for the response that was loaded.
+     */
+    loadExternalTokens(
+        request: SilentRequest,
+        response: ExternalTokenResponse,
+        options: LoadTokenOptions
+    ): AuthenticationResult;
+}

package/src/cache/IWindowStorage.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export interface IWindowStorage<T> {
+    /**
+     * Get the item from the window storage object matching the given key.
+     * @param key
+     */
+    getItem(key: string): T | null;
+
+    /**
+     * Sets the item in the window storage object with the given key.
+     * @param key
+     * @param value
+     */
+    setItem(key: string, value: T): void;
+
+    /**
+     * Removes the item in the window storage object matching the given key.
+     * @param key
+     */
+    removeItem(key: string): void;
+
+    /**
+     * Get all the keys from the window storage object as an iterable array of strings.
+     */
+    getKeys(): string[];
+
+    /**
+     * Returns true or false if the given key is present in the cache.
+     * @param key
+     */
+    containsKey(key: string): boolean;
+}

package/src/cache/MemoryStorage.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IWindowStorage } from "./IWindowStorage";
+
+export class MemoryStorage<T> implements IWindowStorage<T> {
+    private cache: Map<string, T>;
+
+    constructor() {
+        this.cache = new Map<string, T>();
+    }
+
+    getItem(key: string): T | null {
+        return this.cache.get(key) || null;
+    }
+
+    setItem(key: string, value: T): void {
+        this.cache.set(key, value);
+    }
+
+    removeItem(key: string): void {
+        this.cache.delete(key);
+    }
+
+    getKeys(): string[] {
+        const cacheKeys: string[] = [];
+        this.cache.forEach((value: T, key: string) => {
+            cacheKeys.push(key);
+        });
+        return cacheKeys;
+    }
+
+    containsKey(key: string): boolean {
+        return this.cache.has(key);
+    }
+
+    clear(): void {
+        this.cache.clear();
+    }
+}