oidc-spa 7.1.8 → 7.1.9

package/entrypoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"entrypoint.js","sourceRoot":"","sources":["src/entrypoint.ts"],"names":[],"mappings":";;AAKA,sCAwCC;AA7CD,gEAGmC;AAEnC,SAAgB,aAAa,CAAC,MAA+D;IACnF,IAAA,KAAwC,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,EAAlD,WAAW,iBAAA,EAAE,oBAAoB,0BAAiB,CAAC;IAEnD,IAAA,SAAS,GAAK,IAAA,uCAAkB,GAAE,UAAzB,CAA0B;IAE3C,IAAM,aAAa,GAAG,CAAC,SAAS,CAAC;IAEjC,IAAI,aAAa,EAAE,CAAC;QAChB,IAAA,uEAAkD,GAAE,CAAC;QAErD,IAAI,oBAAoB,EAAE,CAAC;YACvB,IAAM,sBAAsB,GAAG,UAAU,CAAC,cAAc,CAAC;YAEzD,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAChD,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;YAEtC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,gBAAgB,EAAE;gBAChD,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,IAAI;gBAChB,KAAK,EAAE,sBAAsB;aAChC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YACd,IAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC;YAEvC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YACvC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAE7B,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE;gBACvC,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,IAAI;gBAChB,KAAK,EAAE,aAAa;aACvB,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED,OAAO,EAAE,aAAa,eAAA,EAAE,CAAC;AAC7B,CAAC"}
+{"version":3,"file":"entrypoint.js","sourceRoot":"","sources":["src/entrypoint.ts"],"names":[],"mappings":";;AAMA,sCA8DC;AApED,gEAGmC;AACnC,0EAAqG;AAErG,SAAgB,aAAa,CAAC,MAM7B;IACS,IAAA,KAAiE,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,EAA3E,WAAW,iBAAA,EAAE,oBAAoB,0BAAA,EAAE,uBAAuB,EAAvB,eAAe,mBAAG,KAAK,KAAiB,CAAC;IAE5E,IAAA,SAAS,GAAK,IAAA,uCAAkB,GAAE,UAAzB,CAA0B;IAE3C,IAAM,aAAa,GAAG,CAAC,SAAS,CAAC;IAEjC,IAAI,aAAa,EAAE,CAAC;QAChB,IAAA,uEAAkD,GAAE,CAAC;QAErD,IAAI,oBAAoB,EAAE,CAAC;YACvB,IAAM,sBAAsB,GAAG,UAAU,CAAC,cAAc,CAAC;YAEzD,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAChD,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;YAEtC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,gBAAgB,EAAE;gBAChD,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,IAAI;gBAChB,KAAK,EAAE,sBAAsB;aAChC,CAAC,CAAC;QACP,CAAC;QAED,IAAI,WAAW,EAAE,CAAC;YACd,IAAM,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC;YAEvC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YACvC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAE7B,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE;gBACvC,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,IAAI;gBAChB,KAAK,EAAE,aAAa;aACvB,CAAC,CAAC;QACP,CAAC;QAED,IAAI,eAAe,EAAE,CAAC;YAClB,IAAM,iBAAiB,GAAG,UAAU,CAAC,SAAS,CAAC;YAE/C,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;YAC3C,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;YAEjC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,WAAW,EAAE;gBAC3C,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,UAAU,EAAE,IAAI;gBAChB,KAAK,EAAE,iBAAiB;aAC3B,CAAC,CAAC;QACP,CAAC;QAED,IAAA,6EAAmD,GAAE,CAAC;IAC1D,CAAC;IAED,OAAO,EAAE,aAAa,eAAA,EAAE,CAAC;AAC7B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oidc-spa",
-    "version": "7.1.8",
+    "version": "7.1.9",
     "description": "Openidconnect client for Single Page Applications",
     "repository": {
         "type": "git",
@@ -41,6 +41,7 @@
         "./src/core/createOidc.ts",
         "./src/core/evtIsUserActive.ts",
         "./src/core/handleOidcCallback.ts",
+        "./src/core/iframeMessageProtection.ts",
         "./src/core/index.ts",
         "./src/core/initialLocationHref.ts",
         "./src/core/isNewBrowserSession.ts",
@@ -64,6 +65,7 @@
         "./src/tools/Evt.ts",
         "./src/tools/StatefulEvt.ts",
         "./src/tools/ValueOrAsyncGetter.ts",
+        "./src/tools/asymmetricEncryption.ts",
         "./src/tools/base64.ts",
         "./src/tools/createObjectThatThrowsIfAccessed.ts",
         "./src/tools/decodeJwt.ts",
@@ -122,6 +124,9 @@
         "./core/handleOidcCallback.d.ts",
         "./core/handleOidcCallback.js",
         "./core/handleOidcCallback.js.map",
+        "./core/iframeMessageProtection.d.ts",
+        "./core/iframeMessageProtection.js",
+        "./core/iframeMessageProtection.js.map",
         "./core/index.d.ts",
         "./core/index.js",
         "./core/index.js.map",
@@ -191,6 +196,9 @@
         "./tools/ValueOrAsyncGetter.d.ts",
         "./tools/ValueOrAsyncGetter.js",
         "./tools/ValueOrAsyncGetter.js.map",
+        "./tools/asymmetricEncryption.d.ts",
+        "./tools/asymmetricEncryption.js",
+        "./tools/asymmetricEncryption.js.map",
         "./tools/base64.d.ts",
         "./tools/base64.js",
         "./tools/base64.js.map",

package/src/core/AuthResponse.ts

@@ -5,15 +5,6 @@ export type AuthResponse = {
     [key: string]: string | undefined;
 };
 
-export function getIsAuthResponse(data: any): data is AuthResponse {
-    return (
-        data instanceof Object &&
-        "state" in data &&
-        typeof data.state === "string" &&
-        Object.values(data).every(value => value === undefined || typeof value === "string")
-    );
-}
-
 export function authResponseToUrl(authResponse: AuthResponse): string {
     let authResponseUrl = "https://dummy.com";
 

package/src/core/handleOidcCallback.ts

@@ -8,6 +8,7 @@ import { assert, id } from "../vendor/frontend/tsafe";
 import type { AuthResponse } from "./AuthResponse";
 import { initialLocationHref } from "./initialLocationHref";
 import { captureFetch } from "./trustedFetch";
+import { encryptAuthResponse } from "./iframeMessageProtection";
 
 captureFetch();
 
@@ -111,7 +112,8 @@ function handleOidcCallback_nonMemoized(): { isHandled: boolean } {
             // NOTE: This is a "better than nothing" approach.
             // Under some circumstances it's possible to get stuck on this url
             // if there is no "next" page in the history for example, navigating
-            // forward is a NoOp. So in that case it's better to navigate to the home.
+            // forward is a NoOp. So in that case it's better to reload the same route
+            // with just the authResponse removed from the url to avoid re-entering here.
             setTimeout(() => {
                 const { protocol, host, pathname, hash } = window.location;
                 window.location.href = `${protocol}//${host}${pathname}${hash}`;
@@ -131,9 +133,9 @@ function handleOidcCallback_nonMemoized(): { isHandled: boolean } {
 
     switch (stateData.context) {
         case "iframe":
-            setTimeout(() => {
-                parent.postMessage(authResponse, location.origin);
-            }, 0);
+            encryptAuthResponse({
+                authResponse
+            }).then(({ encryptedMessage }) => parent.postMessage(encryptedMessage, location.origin));
             break;
         case "redirect":
             markStateDataAsProcessedByCallback({ stateQueryParamValue });

package/src/core/iframeMessageProtection.ts

@@ -0,0 +1,99 @@
+import { assert } from "tsafe/assert";
+import { asymmetricEncrypt, asymmetricDecrypt, generateKeys } from "../tools/asymmetricEncryption";
+import { type AuthResponse } from "./AuthResponse";
+
+const setItem_real = Storage.prototype.setItem;
+
+const SESSION_STORAGE_PREFIX = "oidc-spa_iframe_authResponse_publicKey_";
+
+export function preventSessionStorageSetItemOfPublicKeyByThirdParty() {
+    const setItem_protected = function setItem(this: any, key: string, value: string): void {
+        if (this !== sessionStorage) {
+            return setItem_real.call(this, key, value);
+        }
+
+        if (key.startsWith(SESSION_STORAGE_PREFIX)) {
+            throw new Error(
+                "Attack prevented by oidc-spa. You have malicious code running in your system"
+            );
+        }
+
+        return setItem_real.call(sessionStorage, key, value);
+    };
+
+    {
+        const pd = Object.getOwnPropertyDescriptor(Storage.prototype, "setItem");
+
+        assert(pd !== undefined);
+
+        Object.defineProperty(Storage.prototype, "setItem", {
+            enumerable: pd.enumerable,
+            writable: pd.writable,
+            value: setItem_protected
+        });
+    }
+}
+
+const ENCRYPTED_AUTH_RESPONSES_PREFIX = "oidc-spa_encrypted_authResponse_";
+
+function getSessionStorageKey(params: { stateQueryParamValue: string }) {
+    const { stateQueryParamValue } = params;
+
+    return `${SESSION_STORAGE_PREFIX}${stateQueryParamValue}`;
+}
+
+export async function initIframeMessageProtection(params: { stateQueryParamValue: string }) {
+    const { stateQueryParamValue } = params;
+
+    const { publicKey, privateKey } = await generateKeys();
+
+    const sessionStorageKey = getSessionStorageKey({ stateQueryParamValue });
+
+    setItem_real.call(sessionStorage, sessionStorageKey, publicKey);
+
+    function getIsEncryptedAuthResponse(params: { message: unknown }): boolean {
+        const { message } = params;
+
+        return typeof message === "string" && message.startsWith(ENCRYPTED_AUTH_RESPONSES_PREFIX);
+    }
+
+    async function decodeEncryptedAuth(params: {
+        encryptedAuthResponse: string;
+    }): Promise<{ authResponse: AuthResponse }> {
+        const { encryptedAuthResponse } = params;
+
+        const { message: authResponse_str } = await asymmetricDecrypt({
+            encryptedMessage: encryptedAuthResponse.slice(ENCRYPTED_AUTH_RESPONSES_PREFIX.length),
+            privateKey
+        });
+
+        const authResponse: AuthResponse = JSON.parse(authResponse_str);
+
+        return { authResponse };
+    }
+
+    function clearSessionStoragePublicKey() {
+        sessionStorage.removeItem(sessionStorageKey);
+    }
+
+    return { getIsEncryptedAuthResponse, decodeEncryptedAuth, clearSessionStoragePublicKey };
+}
+
+export async function encryptAuthResponse(params: { authResponse: AuthResponse }) {
+    const { authResponse } = params;
+
+    const publicKey = sessionStorage.getItem(
+        getSessionStorageKey({ stateQueryParamValue: authResponse.state })
+    );
+
+    assert(publicKey !== null, "2293302");
+
+    const { encryptedMessage: encryptedMessage_withoutPrefix } = await asymmetricEncrypt({
+        publicKey,
+        message: JSON.stringify(authResponse)
+    });
+
+    const encryptedMessage = `${ENCRYPTED_AUTH_RESPONSES_PREFIX}${encryptedMessage_withoutPrefix}`;
+
+    return { encryptedMessage };
+}

package/src/core/loginSilent.ts

@@ -5,8 +5,9 @@ import { getStateData, clearStateStore, type StateData } from "./StateData";
 import { getDownlinkAndRtt } from "../tools/getDownlinkAndRtt";
 import { getIsDev } from "../tools/isDev";
 import type { User as OidcClientTsUser } from "../vendor/frontend/oidc-client-ts-and-jwt-decode";
-import { type AuthResponse, getIsAuthResponse } from "./AuthResponse";
+import { type AuthResponse } from "./AuthResponse";
 import { addOrUpdateSearchParam } from "../tools/urlSearchParams";
+import { initIframeMessageProtection } from "./iframeMessageProtection";
 
 type ResultOfLoginSilent =
     | {
@@ -74,6 +75,11 @@ export async function loginSilent(params: {
         return Math.max(BASE_DELAY_MS, dynamicDelay);
     })();
 
+    const { decodeEncryptedAuth, getIsEncryptedAuthResponse, clearSessionStoragePublicKey } =
+        await initIframeMessageProtection({
+            stateQueryParamValue: stateQueryParamValue_instance
+        });
+
     const timeout = setTimeout(async () => {
         dResult.resolve({
             outcome: "failure",
@@ -81,12 +87,20 @@ export async function loginSilent(params: {
         });
     }, timeoutDelayMs);
 
-    const listener = (event: MessageEvent) => {
-        if (!getIsAuthResponse(event.data)) {
+    const listener = async (event: MessageEvent) => {
+        if (event.origin !== window.location.origin) {
+            return;
+        }
+
+        if (
+            !getIsEncryptedAuthResponse({
+                message: event.data
+            })
+        ) {
             return;
         }
 
-        const authResponse = event.data;
+        const { authResponse } = await decodeEncryptedAuth({ encryptedAuthResponse: event.data });
 
         const stateData = getStateData({ stateQueryParamValue: authResponse.state });
 
@@ -181,6 +195,8 @@ export async function loginSilent(params: {
         );
 
     dResult.pr.then(result => {
+        clearSessionStoragePublicKey();
+
         if (result.outcome === "failure") {
             clearStateStore({ stateQueryParamValue: stateQueryParamValue_instance });
         }

package/src/entrypoint.ts

@@ -2,9 +2,16 @@ import {
     handleOidcCallback,
     moveRedirectAuthResponseFromSessionStorageToMemory
 } from "./core/handleOidcCallback";
+import { preventSessionStorageSetItemOfPublicKeyByThirdParty } from "./core/iframeMessageProtection";
 
-export function oidcEarlyInit(params: { freezeFetch: boolean; freezeXMLHttpRequest: boolean }) {
-    const { freezeFetch, freezeXMLHttpRequest } = params ?? {};
+export function oidcEarlyInit(params: {
+    freezeFetch: boolean;
+    freezeXMLHttpRequest: boolean;
+    // NOTE: Made optional just to avoid breaking change.
+    // Will be made mandatory next major.
+    freezeWebSocket?: boolean;
+}) {
+    const { freezeFetch, freezeXMLHttpRequest, freezeWebSocket = false } = params ?? {};
 
     const { isHandled } = handleOidcCallback();
 
@@ -40,6 +47,22 @@ export function oidcEarlyInit(params: { freezeFetch: boolean; freezeXMLHttpReque
                 value: fetch_trusted
             });
         }
+
+        if (freezeWebSocket) {
+            const WebSocket_trusted = globalThis.WebSocket;
+
+            Object.freeze(WebSocket_trusted.prototype);
+            Object.freeze(WebSocket_trusted);
+
+            Object.defineProperty(globalThis, "WebSocket", {
+                configurable: false,
+                writable: false,
+                enumerable: true,
+                value: WebSocket_trusted
+            });
+        }
+
+        preventSessionStorageSetItemOfPublicKeyByThirdParty();
     }
 
     return { shouldLoadApp };

package/src/tools/asymmetricEncryption.ts

@@ -0,0 +1,184 @@
+type AsymmetricKeys = {
+    publicKey: string; // base64-encoded JSON export of CryptoKey
+    privateKey: string; // base64-encoded JSON export of CryptoKey
+};
+
+const INFO_LABEL = "oidc-spa/tools/asymmetricEncryption";
+
+export async function generateKeys(): Promise<AsymmetricKeys> {
+    const keyPair = await crypto.subtle.generateKey(
+        {
+            name: "ECDH",
+            namedCurve: "P-256"
+        },
+        true,
+        ["deriveKey", "deriveBits"]
+    );
+
+    const publicKeyRaw = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
+    const privateKeyRaw = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
+
+    return {
+        publicKey: btoa(JSON.stringify(publicKeyRaw)),
+        privateKey: btoa(JSON.stringify(privateKeyRaw))
+    };
+}
+
+export async function asymmetricEncrypt(params: {
+    publicKey: string;
+    message: string;
+}): Promise<{ encryptedMessage: string }> {
+    const { publicKey, message } = params;
+
+    const importedPublicKey = await crypto.subtle.importKey(
+        "jwk",
+        JSON.parse(atob(publicKey)),
+        {
+            name: "ECDH",
+            namedCurve: "P-256"
+        },
+        false,
+        []
+    );
+
+    const ephemeralKeyPair = await crypto.subtle.generateKey(
+        {
+            name: "ECDH",
+            namedCurve: "P-256"
+        },
+        true,
+        ["deriveKey", "deriveBits"]
+    );
+
+    const sharedSecret = await crypto.subtle.deriveBits(
+        {
+            name: "ECDH",
+            public: importedPublicKey
+        },
+        ephemeralKeyPair.privateKey,
+        256
+    );
+
+    const salt = crypto.getRandomValues(new Uint8Array(16));
+    const infoBytes = new TextEncoder().encode(INFO_LABEL);
+
+    const hkdfKey = await crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, ["deriveKey"]);
+
+    const derivedKey = await crypto.subtle.deriveKey(
+        {
+            name: "HKDF",
+            hash: "SHA-256",
+            salt,
+            info: infoBytes
+        },
+        hkdfKey,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt"]
+    );
+
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const encodedMessage = new TextEncoder().encode(message);
+
+    const ciphertext = await crypto.subtle.encrypt(
+        {
+            name: "AES-GCM",
+            iv
+        },
+        derivedKey,
+        encodedMessage
+    );
+
+    const ephemeralPubKeyRaw = await crypto.subtle.exportKey("jwk", ephemeralKeyPair.publicKey);
+
+    const payload = {
+        ephemeralPubKey: ephemeralPubKeyRaw,
+        iv: Array.from(iv),
+        salt: Array.from(salt),
+        ciphertext: Array.from(new Uint8Array(ciphertext))
+    };
+
+    return {
+        encryptedMessage: btoa(JSON.stringify(payload))
+    };
+}
+
+export async function asymmetricDecrypt(params: {
+    privateKey: string;
+    encryptedMessage: string;
+}): Promise<{ message: string }> {
+    const { privateKey, encryptedMessage } = params;
+
+    const {
+        ephemeralPubKey,
+        iv,
+        salt,
+        ciphertext
+    }: {
+        ephemeralPubKey: JsonWebKey;
+        iv: number[];
+        salt: number[];
+        ciphertext: number[];
+    } = JSON.parse(atob(encryptedMessage));
+
+    const importedPrivateKey = await crypto.subtle.importKey(
+        "jwk",
+        JSON.parse(atob(privateKey)),
+        {
+            name: "ECDH",
+            namedCurve: "P-256"
+        },
+        false,
+        ["deriveKey", "deriveBits"]
+    );
+
+    const importedEphemeralPubKey = await crypto.subtle.importKey(
+        "jwk",
+        ephemeralPubKey,
+        {
+            name: "ECDH",
+            namedCurve: "P-256"
+        },
+        false,
+        []
+    );
+
+    const sharedSecret = await crypto.subtle.deriveBits(
+        {
+            name: "ECDH",
+            public: importedEphemeralPubKey
+        },
+        importedPrivateKey,
+        256
+    );
+
+    const infoBytes = new TextEncoder().encode(INFO_LABEL);
+
+    const hkdfKey = await crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, ["deriveKey"]);
+
+    const derivedKey = await crypto.subtle.deriveKey(
+        {
+            name: "HKDF",
+            hash: "SHA-256",
+            salt: new Uint8Array(salt),
+            info: infoBytes
+        },
+        hkdfKey,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["decrypt"]
+    );
+
+    const decryptedBuffer = await crypto.subtle.decrypt(
+        {
+            name: "AES-GCM",
+            iv: new Uint8Array(iv)
+        },
+        derivedKey,
+        new Uint8Array(ciphertext)
+    );
+
+    return {
+        message: new TextDecoder().decode(decryptedBuffer)
+    };
+}

package/tools/asymmetricEncryption.d.ts

@@ -0,0 +1,18 @@
+type AsymmetricKeys = {
+    publicKey: string;
+    privateKey: string;
+};
+export declare function generateKeys(): Promise<AsymmetricKeys>;
+export declare function asymmetricEncrypt(params: {
+    publicKey: string;
+    message: string;
+}): Promise<{
+    encryptedMessage: string;
+}>;
+export declare function asymmetricDecrypt(params: {
+    privateKey: string;
+    encryptedMessage: string;
+}): Promise<{
+    message: string;
+}>;
+export {};

package/tools/asymmetricEncryption.js

@@ -0,0 +1,181 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKeys = generateKeys;
+exports.asymmetricEncrypt = asymmetricEncrypt;
+exports.asymmetricDecrypt = asymmetricDecrypt;
+var INFO_LABEL = "oidc-spa/tools/asymmetricEncryption";
+function generateKeys() {
+    return __awaiter(this, void 0, void 0, function () {
+        var keyPair, publicKeyRaw, privateKeyRaw;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, crypto.subtle.generateKey({
+                        name: "ECDH",
+                        namedCurve: "P-256"
+                    }, true, ["deriveKey", "deriveBits"])];
+                case 1:
+                    keyPair = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.exportKey("jwk", keyPair.publicKey)];
+                case 2:
+                    publicKeyRaw = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.exportKey("jwk", keyPair.privateKey)];
+                case 3:
+                    privateKeyRaw = _a.sent();
+                    return [2 /*return*/, {
+                            publicKey: btoa(JSON.stringify(publicKeyRaw)),
+                            privateKey: btoa(JSON.stringify(privateKeyRaw))
+                        }];
+            }
+        });
+    });
+}
+function asymmetricEncrypt(params) {
+    return __awaiter(this, void 0, void 0, function () {
+        var publicKey, message, importedPublicKey, ephemeralKeyPair, sharedSecret, salt, infoBytes, hkdfKey, derivedKey, iv, encodedMessage, ciphertext, ephemeralPubKeyRaw, payload;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    publicKey = params.publicKey, message = params.message;
+                    return [4 /*yield*/, crypto.subtle.importKey("jwk", JSON.parse(atob(publicKey)), {
+                            name: "ECDH",
+                            namedCurve: "P-256"
+                        }, false, [])];
+                case 1:
+                    importedPublicKey = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.generateKey({
+                            name: "ECDH",
+                            namedCurve: "P-256"
+                        }, true, ["deriveKey", "deriveBits"])];
+                case 2:
+                    ephemeralKeyPair = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.deriveBits({
+                            name: "ECDH",
+                            public: importedPublicKey
+                        }, ephemeralKeyPair.privateKey, 256)];
+                case 3:
+                    sharedSecret = _a.sent();
+                    salt = crypto.getRandomValues(new Uint8Array(16));
+                    infoBytes = new TextEncoder().encode(INFO_LABEL);
+                    return [4 /*yield*/, crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, ["deriveKey"])];
+                case 4:
+                    hkdfKey = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.deriveKey({
+                            name: "HKDF",
+                            hash: "SHA-256",
+                            salt: salt,
+                            info: infoBytes
+                        }, hkdfKey, { name: "AES-GCM", length: 256 }, false, ["encrypt"])];
+                case 5:
+                    derivedKey = _a.sent();
+                    iv = crypto.getRandomValues(new Uint8Array(12));
+                    encodedMessage = new TextEncoder().encode(message);
+                    return [4 /*yield*/, crypto.subtle.encrypt({
+                            name: "AES-GCM",
+                            iv: iv
+                        }, derivedKey, encodedMessage)];
+                case 6:
+                    ciphertext = _a.sent();
+                    return [4 /*yield*/, crypto.subtle.exportKey("jwk", ephemeralKeyPair.publicKey)];
+                case 7:
+                    ephemeralPubKeyRaw = _a.sent();
+                    payload = {
+                        ephemeralPubKey: ephemeralPubKeyRaw,
+                        iv: Array.from(iv),
+                        salt: Array.from(salt),
+                        ciphertext: Array.from(new Uint8Array(ciphertext))
+                    };
+                    return [2 /*return*/, {
+                            encryptedMessage: btoa(JSON.stringify(payload))
+                        }];
+            }
+        });
+    });
+}
+function asymmetricDecrypt(params) {
+    return __awaiter(this, void 0, void 0, function () {
+        var privateKey, encryptedMessage, _a, ephemeralPubKey, iv, salt, ciphertext, importedPrivateKey, importedEphemeralPubKey, sharedSecret, infoBytes, hkdfKey, derivedKey, decryptedBuffer;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    privateKey = params.privateKey, encryptedMessage = params.encryptedMessage;
+                    _a = JSON.parse(atob(encryptedMessage)), ephemeralPubKey = _a.ephemeralPubKey, iv = _a.iv, salt = _a.salt, ciphertext = _a.ciphertext;
+                    return [4 /*yield*/, crypto.subtle.importKey("jwk", JSON.parse(atob(privateKey)), {
+                            name: "ECDH",
+                            namedCurve: "P-256"
+                        }, false, ["deriveKey", "deriveBits"])];
+                case 1:
+                    importedPrivateKey = _b.sent();
+                    return [4 /*yield*/, crypto.subtle.importKey("jwk", ephemeralPubKey, {
+                            name: "ECDH",
+                            namedCurve: "P-256"
+                        }, false, [])];
+                case 2:
+                    importedEphemeralPubKey = _b.sent();
+                    return [4 /*yield*/, crypto.subtle.deriveBits({
+                            name: "ECDH",
+                            public: importedEphemeralPubKey
+                        }, importedPrivateKey, 256)];
+                case 3:
+                    sharedSecret = _b.sent();
+                    infoBytes = new TextEncoder().encode(INFO_LABEL);
+                    return [4 /*yield*/, crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, ["deriveKey"])];
+                case 4:
+                    hkdfKey = _b.sent();
+                    return [4 /*yield*/, crypto.subtle.deriveKey({
+                            name: "HKDF",
+                            hash: "SHA-256",
+                            salt: new Uint8Array(salt),
+                            info: infoBytes
+                        }, hkdfKey, { name: "AES-GCM", length: 256 }, false, ["decrypt"])];
+                case 5:
+                    derivedKey = _b.sent();
+                    return [4 /*yield*/, crypto.subtle.decrypt({
+                            name: "AES-GCM",
+                            iv: new Uint8Array(iv)
+                        }, derivedKey, new Uint8Array(ciphertext))];
+                case 6:
+                    decryptedBuffer = _b.sent();
+                    return [2 /*return*/, {
+                            message: new TextDecoder().decode(decryptedBuffer)
+                        }];
+            }
+        });
+    });
+}
+//# sourceMappingURL=asymmetricEncryption.js.map