{"version":3,"sources":["crypto.ts"],"sourcesContent":["// deno-lint-ignore-file no-async-promise-executor\nimport { logger } from \"../utils/global_values.ts\";\nimport { Endpoint, Target, WildcardTarget } from \"../types/addressing.ts\";\nimport { SecurityError, ValueError } from \"../types/errors.ts\";\nimport { NetworkUtils } from \"../network/network_utils.ts\";\nimport { Storage } from \"../storage/storage.ts\";\nimport { Runtime } from \"./runtime.ts\";\nimport { displayFatalError } from \"./display.ts\";\nimport { Supranet } from \"../network/supranet.ts\";\nimport { Compiler, to } from \"../datex_all.ts\";\nimport { communicationHub } from \"../network/communication-hub.ts\";\n\n// crypto\nexport const crypto = globalThis.crypto\nif (!crypto) throw new Error(\"The Web Crypto API is required for the DATEX Runtime\");\n\n\n// deno-lint-ignore no-namespace\nexport namespace Crypto {\n    export interface ExportedKeySet {\n        sign: [ArrayBuffer, ArrayBuffer],\n        encrypt: [ArrayBuffer, ArrayBuffer]\n    }\n}\n\n/** takes care of encryption, signing, etc.. */\nexport class Crypto {\n    \n    // cached public keys for endpoints\n    public static public_keys = new WeakMap<Endpoint, [CryptoKey|null, CryptoKey|null]>(); // verify_key, enc_key\n    private static public_keys_exported = new WeakMap<Endpoint, [ArrayBuffer, ArrayBuffer]>(); // only because node crypto is causing problems\n\n    // own keys\n    private static rsa_sign_key:CryptoKey\n    private static rsa_verify_key:CryptoKey\n    private static rsa_dec_key:CryptoKey\n    private static rsa_enc_key:CryptoKey\n\n    // own keys as exported ArrayBuffers\n    private static rsa_sign_key_exported:ArrayBuffer\n    private static rsa_verify_key_exported:ArrayBuffer\n    private static rsa_dec_key_exported:ArrayBuffer\n    private static rsa_enc_key_exported:ArrayBuffer\n\n    public static available = false; // true if own keys loaded\n\n\n    // used for signing/verifying with a sign/verify key\n    public static readonly sign_key_options = {\n        name: \"ECDSA\",\n        hash: {name: \"SHA-384\"},\n    }\n\n    // used to create a new sign/verify key pair\n    public static readonly sign_key_generator = {\n        name: \"ECDSA\",\n        namedCurve: \"P-384\"\n    }\n\n    // used for encryption/decryption keys\n    public static readonly enc_key_options = {\n        name: \"RSA-OAEP\",\n        modulusLength: 4096,\n        publicExponent: new Uint8Array([1, 0, 1]),\n        hash: \"SHA-256\"\n    }\n    // used for import\n    public static readonly enc_key_import = {\n        name: \"RSA-OAEP\",\n        hash: \"SHA-256\"\n    }\n\n    static readonly SIGN_BUFFER_SIZE = 96;\n    static readonly IV_BUFFER_SIZE = 16;\n\n    /** Sign + Verify */\n    static async sign(buffer:ArrayBuffer): Promise<ArrayBuffer> {\n        if (!this.available) {\n            displayFatalError('missing-private-keys');\n            throw new SecurityError(\"Cannot sign DATEX requests, missing private keys\");\n        }\n        return await crypto.subtle.sign(this.sign_key_options, this.rsa_sign_key, buffer);\n    }\n    static async verify(data:ArrayBuffer, signature:ArrayBuffer, endpoint:Endpoint): Promise<boolean> {\n        const keys = await this.getKeysForEndpoint(endpoint);\n        if (!keys || !keys[0]) return false;\n        return await crypto.subtle.verify(this.sign_key_options, keys[0], signature, data);\n    }\n\n    /** Encypt + Decrypt (RSA) */\n    static async encrypt(buffer:ArrayBuffer, endpoint:Endpoint): Promise<ArrayBuffer> {\n        if (!this.available) {\n            displayFatalError('missing-private-keys');\n            throw new SecurityError(\"Cannot encrypt DATEX requests, missing private keys\");\n        }\n        const keys = await this.getKeysForEndpoint(endpoint);\n        if (!keys || keys[1]==null) throw new SecurityError(\"Cannot encrypt DATEX requests, could not get keys for endpoint\");\n        return await crypto.subtle.encrypt(\"RSA-OAEP\", keys[1], buffer);\n    }\n    static async decrypt(data:ArrayBuffer): Promise<ArrayBuffer> {\n        return await crypto.subtle.decrypt(\"RSA-OAEP\", this.rsa_dec_key, data);\n    }\n\n\n    /** Symmetric Encypt + Decrypt (AES-GCM) */\n    // returns [encrypted, iv]\n    static async encryptSymmetric(data:ArrayBuffer, key:CryptoKey): Promise<[ArrayBuffer,Uint8Array]> {\n        const iv = crypto.getRandomValues(new Uint8Array(this.IV_BUFFER_SIZE));\n        return [await crypto.subtle.encrypt({name:\"AES-GCM\", iv: iv}, key, data), iv]\n    }\n\n    // returns decrypted\n    static async decryptSymmetric(encrypted:ArrayBuffer, key:CryptoKey, iv:Uint8Array): Promise<ArrayBuffer> {\n        try {\n            return await crypto.subtle.decrypt({name:\"AES-GCM\", iv: iv}, key, encrypted);\n        } catch {\n            throw new SecurityError(\"Invalid encrypted DATEX\");\n        }\n    }\n\n    // returns an assymetrically encrypted symmetric key\n    static async encryptSymmetricKeyForEndpoint(key:CryptoKey, endpoint:Endpoint) {\n        const exported_key = await crypto.subtle.exportKey(\"raw\", key);\n        return this.encrypt(exported_key, endpoint);\n    }\n\n    // returns a symmetric encryption key\n    static async extractEncryptedKey(encrypted: ArrayBuffer): Promise<CryptoKey> {\n        const key_data = await this.decrypt(encrypted);\n        return crypto.subtle.importKey(\"raw\",  key_data, \"AES-GCM\", true, [\"encrypt\", \"decrypt\"]);\n    }\n\n    // generates a new symmetric (AES) key\n    static generateSymmetricKey():Promise<CryptoKey> {\n        return crypto.subtle.generateKey({\n                name: \"AES-GCM\",\n                length: 256\n            },true, [\"encrypt\", \"decrypt\"]\n        );\n    }\n\n\n    // returns the public verify + encrypt keys for an endpoint (from cache or from network)\n    static getKeysForEndpoint(endpoint:Endpoint) {\n        if (this.public_keys.has(endpoint) || this.public_keys.has(endpoint.main)) {\n            return (this.public_keys.get(endpoint)||this.public_keys.get(endpoint.main)) as [CryptoKey, CryptoKey];\n        }\n        // keys not found, request from network\n        else {\n            return this.requestKeys(endpoint.main);\n        }\n    }\n\n    static async getExportedKeysForEndpoint(endpoint:Endpoint):Promise<[ArrayBuffer?, ArrayBuffer?]> {\n        const keys = await this.getKeysForEndpoint(endpoint);\n        return [\n            keys[0] ? await this.exportPublicKey(keys[0]) : undefined,\n            keys[1] ? await this.exportPublicKey(keys[1]) : undefined\n        ];\n    }\n\n    // saves public verify and encrypt keys for an endpoint locally\n    static async bindKeys(endpoint:Endpoint, verify_key:ArrayBuffer, enc_key:ArrayBuffer):Promise<boolean> {\n        if (!(endpoint instanceof Endpoint)) throw new ValueError(\"Invalid endpoint\");\n        if (verify_key && !(verify_key instanceof ArrayBuffer)) throw new ValueError(\"Invalid verify key\");\n        if (enc_key && !(enc_key instanceof ArrayBuffer)) throw new ValueError(\"Invalid encryption key\");\n\n        // always bind to main endpoint\n        endpoint = endpoint.main;\n\n        if (this.public_keys.has(endpoint)) return false; // keys already exist\n \n        try {      \n            const keys = [\n                verify_key ? await Crypto.importVerifyKey(verify_key) : null,\n                enc_key ? await Crypto.importEncKey(enc_key): null\n            ] as [CryptoKey | null, CryptoKey | null];      \n            const exportedKeys = [verify_key, enc_key] as [ArrayBuffer, ArrayBuffer];\n\n            this.public_keys.set(endpoint, keys)\n            this.public_keys_exported.set(endpoint, exportedKeys);\n\n            return true;\n        } catch(e) {\n            logger.error(e);\n            throw new Error(\"Could not register keys for endpoint \" + endpoint + \" (invalid keys or no permisssion)\");\n        }\n    }\n\n    // list of all endpoints with actively used keys\n    static #activeEndpoints = new WeakSet<Endpoint>();\n\n\n    /**\n     * Adds an endpoint to the list of active endpoints and makes\n     * sure the keys are stored persistently\n     * @returns true if keys could be stored\n     */\n    static activateEndpoint(endpoint: Endpoint) {\n        endpoint = endpoint.main;\n        if (!this.#activeEndpoints.has(endpoint)) {\n            this.#activeEndpoints.add(endpoint)\n            return this.storeKeys(endpoint);\n        }\n        return Promise.resolve(true)\n    }\n\n    /**\n     * Stores the keys for an endpoint persistently and\n     * updates the last used timestamp\n     */\n    static async storeKeys(endpoint:Endpoint, exportedKeys?: [ArrayBuffer, ArrayBuffer]) {\n        // always bind to main endpoint\n        endpoint = endpoint.main;\n\n        if (!exportedKeys && !this.public_keys_exported.has(endpoint)) return false;\n        if (!exportedKeys) exportedKeys = this.public_keys_exported.get(endpoint)!;\n\n        const storage_item_key = \"keys_\"+endpoint;\n        if (await Storage.hasItem(storage_item_key)) return true; // keys already in storage\n        else {\n            // validate with stored hash if exists\n            const storedHash = await Storage.getItem('hash_keys_' + endpoint) as string;\n            const currentHash = await Compiler.getValueHashString(exportedKeys);\n            if (storedHash && storedHash !== currentHash) {\n                throw new SecurityError(\"Keys for \" + endpoint + \" are not valid (Fingerprint mismatch)\");\n            }\n            logger.debug(\"Storing keys for \" + endpoint + \" persistently\")\n            await Storage.setItem(storage_item_key, [...exportedKeys, Date.now()]);\n            if (storedHash) await Storage.removeItem('hash_keys_' + endpoint);\n            return true;\n        }\n    }\n\n    static KEY_CLEANUP_INTERVAL = 1000*60*60; // 1 hour\n    static MAX_KEY_LIFETIME = 1000*60*60*24*7; // 7 days\n\n    static initCleanup() {\n        // run cleanup once at startup\n        this.cleanupKeys();\n        // run cleanup every hour\n        setInterval(() => this.cleanupKeys(), this.KEY_CLEANUP_INTERVAL);\n    }\n\n    static async cleanupKeys() {\n        let removeCount = 0;\n        let totalCount = 0;\n\n        for (const key of await Storage.getItemKeysStartingWith(\"keys_\")) {\n            try {\n                totalCount++;\n                const endpoint = Endpoint.get(key.replace('keys_', ''))\n\n                let isActiveEndpoint = false\n                // is active endpoint if in activeEndpoints list and endpoint still online\n                if (endpoint instanceof Endpoint && this.#activeEndpoints.has(endpoint)) {\n                    isActiveEndpoint = await endpoint.isOnline();\n                    this.#activeEndpoints.delete(endpoint);\n                }\n                \n                const data = await Storage.getItem(key);\n                if (!(data instanceof Array)) {\n                    await Storage.removeItem(key);\n                    continue;\n                }\n                const [verifyKey, encKey, timestamp] = data;\n                if (!isActiveEndpoint && (!timestamp || Date.now() - timestamp > this.MAX_KEY_LIFETIME)) {\n                    await Storage.removeItem(key);\n                    // store key hash\n                    await Storage.setItem('hash_keys_' + endpoint, await Compiler.getValueHashString([verifyKey, encKey]));\n                    removeCount++;\n                }\n                else {\n                    await Storage.setItem(key, [verifyKey, encKey, Date.now()]);\n                }\n            }\n            catch (e) {\n                console.error(e)\n            }\n        }\n\n        const totalKeyHashCount = await Storage.getItemCountStartingWith('hash_keys_');\n\n        logger.debug(`Cleaned up ${removeCount} stored keys. Remaining: ${totalCount-removeCount} keys and ${totalKeyHashCount} key hashes.`);\n\n        if (totalCount > 1000) {\n            logger.warn(\"Stored keys entries exceed 1000\");\n        }\n        if (totalKeyHashCount > 5000) {\n            logger.warn(\"Stored key hash entries exceed 5000\");\n        }\n\n    }\n\n    static #waiting_key_requests = new Map<Endpoint, Promise<[CryptoKey, CryptoKey]>>();\n\n    /**\n     * Checks if the current public keys match the offical public keys for this endpoint\n     */\n    static async validateOwnKeysAgainstNetwork() {\n        if (!communicationHub.connected) {\n            logger.debug(\"Could not validate local keys against registered public keys, not connected to Supranet\")\n            return\n        }\n        try {\n            const ownKeys = await Promise.all(\n                this.getOwnPublicKeys().map(k => this.exportPublicKeyBase64(k))\n            )\n            const networkKeys = await Promise.all(\n                (await this.requestKeys(Runtime.endpoint)).map(k => k ? this.exportPublicKeyBase64(k) : null)\n            );\n            if (ownKeys[0] !== networkKeys[0] || ownKeys[1] !== networkKeys[1]) {\n                logger.error `The local keys for ${Runtime.endpoint} do not match the registered public keys.`\n                displayFatalError(\"invalid-local-keys\")\n            }\n        }\n        catch {\n            logger.debug(\"Could not validate local keys against registered public keys\")\n        }\n    }\n    \n    // loads keys from network or cache\n    static requestKeys(endpoint:Endpoint):Promise<[CryptoKey?, CryptoKey?]> {\n\n        endpoint = endpoint.main;\n\n        // already requesting/loading keys for this endpoint\n        if (this.#waiting_key_requests.has(endpoint)) return <Promise<[CryptoKey, CryptoKey]>>this.#waiting_key_requests.get(endpoint);\n\n        let keyPromise:Promise<[CryptoKey, CryptoKey]>;\n        this.#waiting_key_requests.set(endpoint, keyPromise = new Promise(async (resolve, reject)=>{\n\n            let exported_keys:[ArrayBuffer, ArrayBuffer]|void = undefined;\n\n            // first check cache:\n            if (await Storage.hasItem(\"keys_\"+endpoint)) {\n                exported_keys = await Storage.getItem(\"keys_\"+endpoint)\n                logger.debug(\"getting keys from cache for \" + endpoint);\n            }\n            if (!exported_keys) {\n                logger.debug(\"requesting keys for \" + endpoint);\n\n                // get endpoint public keys\n                // TODO: don't sign?, does not work when running as @+unyt2: await datex('#public.Blockchain.getEndpointPublicKeys(?)', [endpoint], Target.get('@+unyt2'), false)\n                try {\n                    try {\n                        exported_keys = await Runtime.Blockchain!.getEndpointPublicKeys(endpoint);\n                    }\n                    catch {\n                        logger.debug(\"Blockchain request failed, trying network interface\");\n                    }\n                    if (!exported_keys) exported_keys = await NetworkUtils.get_keys(endpoint);\n                    // if (exported_keys) await this.storeKeys(endpoint, exported_keys);\n                    if (!exported_keys) {\n                        reject(new Error(\"could not get keys from network\"));\n                        this.#waiting_key_requests.delete(endpoint); // remove from key promises\n                        return;\n                    }\n                }\n                catch (e) {\n                    console.error(e);\n                    reject(new Error(\"could not get keys for \" + endpoint + \" from network\"));\n                    this.#waiting_key_requests.delete(endpoint); // remove from key promises\n                    return;\n                }\n            }\n    \n            // convert to CryptoKeys\n            try {\n                const keys:[CryptoKey, CryptoKey] = [await this.importVerifyKey(exported_keys[0])||null, await this.importEncKey(exported_keys[1])||null];\n                this.public_keys.set(endpoint, keys);\n                this.public_keys_exported.set(endpoint, exported_keys);\n                logger.debug(\"saving keys for \" + endpoint);\n                resolve(keys);\n                this.#waiting_key_requests.delete(endpoint); // remove from key promises\n                return;\n            }\n            catch (e) {\n                console.log(e);\n                reject(new Error(\"Error importing keys for \" + endpoint));\n                await Storage.removeItem(\"keys_\"+endpoint);\n                this.#waiting_key_requests.delete(endpoint); // remove from key promises\n                return;\n            }\n\n        }));\n\n        return keyPromise;\n    }\n\n\n    // set own public and private keys, returns the exported base64 keys\n    static async loadOwnKeys(verify_key:ArrayBuffer|CryptoKey, sign_key:ArrayBuffer|CryptoKey, enc_key:ArrayBuffer|CryptoKey, dec_key:ArrayBuffer|CryptoKey) {\n        \n        // export/load keys\n\n        if (verify_key instanceof ArrayBuffer) {\n            this.rsa_verify_key_exported = verify_key;\n            this.rsa_verify_key = await this.importVerifyKey(this.rsa_verify_key_exported);\n        }\n        else {\n            this.rsa_verify_key_exported = await this.exportPublicKey(verify_key);\n            this.rsa_verify_key = verify_key;\n        }\n        \n        if (sign_key instanceof ArrayBuffer) {\n            this.rsa_sign_key_exported = sign_key;\n            this.rsa_sign_key = await this.importSignKey(this.rsa_sign_key_exported);\n        }\n        else {\n            this.rsa_sign_key_exported = await this.exportPrivateKey(sign_key);\n            this.rsa_sign_key = sign_key;\n        }\n\n        if (enc_key instanceof ArrayBuffer) {\n            this.rsa_enc_key_exported = enc_key;\n            this.rsa_enc_key = await this.importEncKey(this.rsa_enc_key_exported);\n        }\n        else {\n            this.rsa_enc_key_exported = await this.exportPublicKey(enc_key);\n            this.rsa_enc_key = enc_key;\n        }\n\n        if (dec_key instanceof ArrayBuffer) {\n            this.rsa_dec_key_exported = dec_key;\n            this.rsa_dec_key = await this.importDecKey(this.rsa_dec_key_exported);\n        }\n        else {\n            this.rsa_dec_key_exported = await this.exportPrivateKey(dec_key);\n            this.rsa_dec_key = dec_key;\n        }\n\n        // save in local endpoint key storage\n        this.saveOwnPublicKeysInEndpointKeyMap();\n        this.available = true; // encryption / signing now possible\n\n        return [this.rsa_verify_key_exported, this.rsa_sign_key_exported, this.rsa_enc_key_exported, this.rsa_dec_key_exported]\n    }\n\n\n    static saveOwnPublicKeysInEndpointKeyMap () {\n        // save in local endpoint key storage\n        if (!this.public_keys.has(Runtime.endpoint)) this.public_keys.set(Runtime.endpoint.main, [null,null]);\n        (<[CryptoKey?, CryptoKey?]>this.public_keys.get(Runtime.endpoint.main))[0] = this.rsa_verify_key;\n        (<[CryptoKey?, CryptoKey?]>this.public_keys.get(Runtime.endpoint.main))[1] = this.rsa_enc_key;\n    }\n\n    // returns current public verify + encrypt keys\n    static getOwnPublicKeysExported():[ArrayBuffer, ArrayBuffer] {\n        return [this.rsa_verify_key_exported, this.rsa_enc_key_exported]\n    }\n    static getOwnPublicKeys():[CryptoKey, CryptoKey] {\n        return [this.rsa_verify_key, this.rsa_enc_key]\n    }\n\n\n    // returns the current private sign and decrypt keys\n    static getOwnPrivateKeysExported():[ArrayBuffer, ArrayBuffer] {\n        return [this.rsa_sign_key_exported, this.rsa_dec_key_exported]\n    }\n    static getOwnPrivateKeys():[CryptoKey, CryptoKey] {\n        return [this.rsa_sign_key, this.rsa_dec_key]\n    }\n\n\n    // // returns current exported public sign + encrypt key for an endpoint, if found\n    // static async getEndpointPublicKeys(endpoint:Endpoint):Promise<[ArrayBuffer, ArrayBuffer]> {\n    //     let keys:[CryptoKey, CryptoKey];\n    //     if (this.public_keys.has(endpoint)) keys = this.public_keys.get(endpoint);\n    //     else throw new Error(\"No public keys available for this endpoint: \" + endpoint);\n    //     return [\n    //         keys[0] ? await this.exportPublicKey(keys[0]) : null,\n    //         keys[1] ? await this.exportPublicKey(keys[1]) : null\n    //     ];\n    // }\n\n    // // return already exported keys\n    // static async getEndpointPublicKeys2(endpoint:Endpoint):Promise<[ArrayBuffer, ArrayBuffer]> {\n    //     if (this.public_keys_exported.has(endpoint)) return this.public_keys_exported.get(endpoint);\n    //     else throw new Error(\"no public keys available for this endpoint: \" + endpoint);\n    // }\n\n\n    // generate new sign + encryption (public + private) keys, returns base64 verify, sign, enc, dec keys\n    static async createOwnKeys(): Promise<Crypto.ExportedKeySet> { \n        // create new encrpytion + sign key pair\n        const [enc_key_pair, sign_key_pair] = await this.generateNewKeyPair();\n    \n        this.rsa_dec_key = enc_key_pair.privateKey\n        this.rsa_enc_key = enc_key_pair.publicKey\n        this.rsa_sign_key = sign_key_pair.privateKey\n        this.rsa_verify_key = sign_key_pair.publicKey\n\n        this.rsa_enc_key_exported = await this.exportPublicKey(this.rsa_enc_key);\n        this.rsa_dec_key_exported = await this.exportPrivateKey(this.rsa_dec_key);\n        this.rsa_verify_key_exported = await this.exportPublicKey(this.rsa_verify_key);\n        this.rsa_sign_key_exported = await this.exportPrivateKey(this.rsa_sign_key);\n\n        // save in local endpoint key storage\n        this.saveOwnPublicKeysInEndpointKeyMap();\n        this.available = true; // encryption / signing now possible\n\n        return {\n            sign: [this.rsa_verify_key_exported, this.rsa_sign_key_exported],\n            encrypt: [this.rsa_enc_key_exported, this.rsa_dec_key_exported]\n        }\n    }\n\n    static async generateNewKeys(): Promise<Crypto.ExportedKeySet> { \n        // create new encrpytion + sign key pair\n        const [enc_key_pair, sign_key_pair] = await this.generateNewKeyPair();\n    \n        const rsa_enc_key_exported = await this.exportPublicKey(enc_key_pair.publicKey);\n        const rsa_dec_key_exported = await this.exportPrivateKey(enc_key_pair.privateKey);\n        const rsa_verify_key_exported = await this.exportPublicKey(sign_key_pair.publicKey);\n        const rsa_sign_key_exported = await this.exportPrivateKey(sign_key_pair.privateKey);\n\n        return {\n            sign: [rsa_verify_key_exported, rsa_sign_key_exported],\n            encrypt: [rsa_enc_key_exported, rsa_dec_key_exported]\n        }\n    }\n\n    private static async generateNewKeyPair() {\n        // create new encrpytion key pair\n        const enc_key_pair = <CryptoKeyPair> await crypto.subtle.generateKey(\n            this.enc_key_options,\n            true,\n            [\"encrypt\", \"decrypt\"]\n        );\n\n        // create new sign key pair\n        const sign_key_pair = <CryptoKeyPair>await crypto.subtle.generateKey(\n            this.sign_key_generator,\n            true,\n            [\"sign\", \"verify\"]\n        );\n        return [enc_key_pair, sign_key_pair];\n    }\n\n    // export an public key to base64\n    public static async exportPublicKeyBase64(key: CryptoKey): Promise<string> {\n        return btoa(globalThis.String.fromCharCode.apply(null, [...new Uint8Array(await this.exportPublicKey(key))]));\n    }\n    // export a private key to base64\n    public static async exportPrivateKeyBase64(key: CryptoKey): Promise<string> {\n        return btoa(globalThis.String.fromCharCode.apply(null, [...new Uint8Array(await this.exportPrivateKey(key))]));\n    }\n\n    // export an public key\n    public static exportPublicKey(key: CryptoKey): Promise<ArrayBuffer> {\n        return crypto.subtle.exportKey(\"spki\", key);\n    }\n    // export a private key\n    public static exportPrivateKey(key: CryptoKey): Promise<ArrayBuffer> {\n        return crypto.subtle.exportKey(\"pkcs8\", key);\n    }\n\n    // import private keys: sign, dec\n    public static async importSignKey(key: string|ArrayBuffer): Promise<CryptoKey> {\n        const key_buffer = key instanceof ArrayBuffer ? new Uint8Array(key) : Uint8Array.from(atob(key), c => c.charCodeAt(0)).buffer;\n        return await crypto.subtle.importKey(\"pkcs8\", key_buffer, this.sign_key_generator, true, [\"sign\"])\n    }\n    public static async importDecKey(key: string|ArrayBuffer): Promise<CryptoKey> {\n        const key_buffer = key instanceof ArrayBuffer ? new Uint8Array(key) : Uint8Array.from(atob(key), c => c.charCodeAt(0)).buffer;\n        return await crypto.subtle.importKey(\"pkcs8\", key_buffer, this.enc_key_import, true, [\"decrypt\"])\n    }\n    \n    // import public keys: enc, verify\n    public static async importVerifyKey(key: string|ArrayBuffer): Promise<CryptoKey> {\n        const key_buffer = key instanceof ArrayBuffer ? new Uint8Array(key) : Uint8Array.from(atob(key), c => c.charCodeAt(0)).buffer;\n        return await crypto.subtle.importKey(\"spki\", key_buffer, this.sign_key_generator, true, [\"verify\"])\n    }\n    public static async importEncKey(key: string|ArrayBuffer): Promise<CryptoKey> {\n        const key_buffer = key instanceof ArrayBuffer ? new Uint8Array(key) : Uint8Array.from(atob(key), c => c.charCodeAt(0));\n        return await crypto.subtle.importKey(\"spki\", key_buffer, this.enc_key_import, true, [\"encrypt\"])\n    }\n\n}"],"names":["logger","Endpoint","SecurityError","ValueError","NetworkUtils","Storage","Runtime","displayFatalError","Compiler","communicationHub","crypto","globalThis","Error","Crypto","public_keys","WeakMap","public_keys_exported","rsa_sign_key","rsa_verify_key","rsa_dec_key","rsa_enc_key","rsa_sign_key_exported","rsa_verify_key_exported","rsa_dec_key_exported","rsa_enc_key_exported","available","sign_key_options","name","hash","sign_key_generator","namedCurve","enc_key_options","modulusLength","publicExponent","Uint8Array","enc_key_import","SIGN_BUFFER_SIZE","IV_BUFFER_SIZE","sign","buffer","subtle","verify","data","signature","endpoint","keys","getKeysForEndpoint","encrypt","decrypt","encryptSymmetric","key","iv","getRandomValues","decryptSymmetric","encrypted","encryptSymmetricKeyForEndpoint","exported_key","exportKey","extractEncryptedKey","key_data","importKey","generateSymmetricKey","generateKey","length","has","main","get","requestKeys","getExportedKeysForEndpoint","exportPublicKey","undefined","bindKeys","verify_key","enc_key","ArrayBuffer","importVerifyKey","importEncKey","exportedKeys","set","e","error","WeakSet","activateEndpoint","Promise","resolve","add","storeKeys","storage_item_key","hasItem","storedHash","getItem","currentHash","getValueHashString","debug","setItem","Date","now","removeItem","KEY_CLEANUP_INTERVAL","MAX_KEY_LIFETIME","initCleanup","cleanupKeys","setInterval","removeCount","totalCount","getItemKeysStartingWith","replace","isActiveEndpoint","isOnline","delete","Array","verifyKey","encKey","timestamp","console","totalKeyHashCount","getItemCountStartingWith","warn","Map","validateOwnKeysAgainstNetwork","connected","ownKeys","all","getOwnPublicKeys","map","k","exportPublicKeyBase64","networkKeys","keyPromise","reject","exported_keys","Blockchain","getEndpointPublicKeys","get_keys","log","loadOwnKeys","sign_key","dec_key","importSignKey","exportPrivateKey","importDecKey","saveOwnPublicKeysInEndpointKeyMap","getOwnPublicKeysExported","getOwnPrivateKeysExported","getOwnPrivateKeys","createOwnKeys","enc_key_pair","sign_key_pair","generateNewKeyPair","privateKey","publicKey","generateNewKeys","btoa","String","fromCharCode","apply","exportPrivateKeyBase64","key_buffer","from","atob","c","charCodeAt"],"mappings":"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","sourceRoot":"/lib/datex-core-js-legacy-0.3.15/runtime/","file":"crypto.ts"}