oidc-spa 7.2.0-rc.1 → 7.2.0-rc.2

package/src/tools/asymmetricEncryption.ts

@@ -1,184 +0,0 @@
-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/src/tools/decodeJwt.ts

@@ -1,95 +0,0 @@
-// Copy pasted jwt-decode v4.0.0
-
-export interface JwtDecodeOptions {
-    header?: boolean;
-}
-
-export interface JwtHeader {
-    typ?: string;
-    alg?: string;
-    kid?: string;
-}
-
-export interface JwtPayload {
-    iss?: string;
-    sub?: string;
-    aud?: string[] | string;
-    exp?: number;
-    nbf?: number;
-    iat?: number;
-    jti?: string;
-}
-
-export class InvalidTokenError extends Error {}
-
-InvalidTokenError.prototype.name = "InvalidTokenError";
-
-function b64DecodeUnicode(str: string) {
-    return decodeURIComponent(
-        atob(str).replace(/(.)/g, (_m, p) => {
-            let code = (p as string).charCodeAt(0).toString(16).toUpperCase();
-            if (code.length < 2) {
-                code = "0" + code;
-            }
-            return "%" + code;
-        })
-    );
-}
-
-function base64UrlDecode(str: string) {
-    let output = str.replace(/-/g, "+").replace(/_/g, "/");
-    switch (output.length % 4) {
-        case 0:
-            break;
-        case 2:
-            output += "==";
-            break;
-        case 3:
-            output += "=";
-            break;
-        default:
-            throw new Error("base64 string is not of the correct length");
-    }
-
-    try {
-        return b64DecodeUnicode(output);
-    } catch (err) {
-        return atob(output);
-    }
-}
-
-function jwtDecode<T = JwtHeader>(token: string, options: JwtDecodeOptions & { header: true }): T;
-function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;
-function jwtDecode<T = JwtHeader | JwtPayload>(token: string, options?: JwtDecodeOptions): T {
-    if (typeof token !== "string") {
-        throw new InvalidTokenError("Invalid token specified: must be a string");
-    }
-
-    options ||= {};
-
-    const pos = options.header === true ? 0 : 1;
-    const part = token.split(".")[pos];
-
-    if (typeof part !== "string") {
-        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
-    }
-
-    let decoded: string;
-    try {
-        decoded = base64UrlDecode(part);
-    } catch (e) {
-        throw new InvalidTokenError(
-            `Invalid token specified: invalid base64 for part #${pos + 1} (${(e as Error).message})`
-        );
-    }
-
-    try {
-        return JSON.parse(decoded) as T;
-    } catch (e) {
-        throw new InvalidTokenError(
-            `Invalid token specified: invalid json for part #${pos + 1} (${(e as Error).message})`
-        );
-    }
-}
-
-export const decodeJwt = jwtDecode;

package/src/tools/getIsValidRemoteJson.ts

@@ -1,18 +0,0 @@
-export function getIsValidRemoteJson(url: string): Promise<boolean> {
-    return fetch(url).then(
-        async response => {
-            if (!response.ok) {
-                return false;
-            }
-
-            try {
-                await response.json();
-            } catch {
-                return false;
-            }
-
-            return true;
-        },
-        () => false
-    );
-}

package/src/tools/getUserEnvironmentInfo.ts

@@ -1,42 +0,0 @@
-export function getUserEnvironmentInfo(): string {
-    function safeGet<T>(getter: () => T, fallback: string = "Unknown"): string {
-        try {
-            const value = getter();
-            return value != null ? String(value) : fallback;
-        } catch {
-            return fallback;
-        }
-    }
-
-    const ua = safeGet(() => navigator.userAgent);
-    const platform = safeGet(() => navigator.platform);
-    const language = safeGet(() => navigator.language || (navigator as any).userLanguage);
-    const screenSize = safeGet(() => `${screen.width}x${screen.height}`);
-    const timezone = safeGet(() => Intl.DateTimeFormat().resolvedOptions().timeZone);
-
-    const browser: string = (() => {
-        if (ua.includes("Firefox/")) return "Firefox";
-        if (ua.includes("Edg/")) return "Edge";
-        if (ua.includes("Chrome/") && !ua.includes("Edg/")) return "Chrome";
-        if (ua.includes("Safari/") && !ua.includes("Chrome/")) return "Safari";
-        if (ua.includes("OPR/") || ua.includes("Opera/")) return "Opera";
-        return "Unknown";
-    })();
-
-    const os: string = (() => {
-        if (platform.startsWith("Win")) return "Windows";
-        if (platform.startsWith("Mac")) return "macOS";
-        if (platform.startsWith("Linux")) return "Linux";
-        if (/Android/.test(ua)) return "Android";
-        if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
-        return "Unknown";
-    })();
-
-    return `Browser: ${browser}
-OS: ${os}
-Platform: ${platform}
-Language: ${language}
-Screen: ${screenSize}
-Timezone: ${timezone}
-User Agent: ${ua}`;
-}

package/src/vendor/backend/evt.ts

@@ -1,2 +0,0 @@
-export { Evt } from "evt";
-export { throttleTime } from "evt/operators/throttleTime";

package/src/vendor/backend/jsonwebtoken.ts

@@ -1 +0,0 @@
-export * from "jsonwebtoken";

package/src/vendor/backend/node-fetch.ts

@@ -1,2 +0,0 @@
-import fetch from "node-fetch";
-export { fetch };

package/src/vendor/backend/node-jose.ts

@@ -1 +0,0 @@
-export * from "node-jose";

package/src/vendor/backend/tsafe.ts

@@ -1,5 +0,0 @@
-export { assert, is } from "tsafe/assert";
-export { id } from "tsafe/id";
-export { isAmong } from "tsafe/isAmong";
-export type { Equals } from "tsafe";
-export { exclude } from "tsafe/exclude";

package/src/vendor/backend/zod.ts

@@ -1 +0,0 @@
-export * from "zod";