jsonauthtoken 3.0.0 → 3.0.2

package/dist/index.js

@@ -6,11 +6,11 @@ const runtime_config_1 = require("./config/runtime.config");
 const algo_config_1 = require("./config/algo.config");
 const functions_lib_1 = require("./lib/functions.lib");
 const timeformat_1 = require("./lib/timeformat");
-const crypto_1 = require("./crypto/crypto");
+const runtime_1 = require("./runtime/runtime");
 class JATClass {
     runtime;
     dev = false;
-    crypto = new crypto_1.Crypto();
+    crypto = new runtime_1.RuntimeCrypto();
     constructor(config) {
         try {
             if (config && config.dev == true)
@@ -67,7 +67,7 @@ class JATClass {
     }
 }
 class PrivatePublicKeyGeneration {
-    crypto = new crypto_1.Crypto();
+    crypto = new runtime_1.RuntimeCrypto();
     async generateKeyPair(runtime, dev) {
         let finalRuntime = (0, runtime_config_1.detectRuntime)();
         const development = dev === true ? true : false;

package/dist/{crypto/node.crypto.d.ts → runtime/node.runtime.d.ts}

@@ -1,29 +1,31 @@
 export declare class NodeCrypto {
+    private crypto;
+    private __init;
     private _encrypt;
     private _decrypt;
     private _rsaPublicKeyGeneration;
     private _rsaPrivatePublicKeyGeneration;
-    encrypt(algo: 'aes-256-gcm', key: string, payload: any, exp: number): string;
+    encrypt(algo: 'aes-256-gcm', key: string, payload: any, exp: number): Promise<string>;
     decrypt<T>(algo: 'aes-256-gcm', key: string, encryptedData: {
         iv: string;
         encrypted: string;
         tag: string;
-    }): {
+    }): Promise<{
         payload: T;
         exp: number;
-    };
-    encryptRSA(payload: any, publicKey: string, exp: number): string;
+    }>;
+    encryptRSA(payload: any, publicKey: string, exp: number): Promise<string>;
     decryptRSA<T>(privateKey: string, encryptedKey: string, encryptedData: {
         iv: string;
         encrypted: string;
         tag: string;
-    }): {
+    }): Promise<{
         payload: T;
         exp: number;
-    };
-    rsaPrivatePublicKeyGeneration(): {
+    }>;
+    rsaPrivatePublicKeyGeneration(): Promise<{
         privateKey: string;
         publicKey: string;
-    };
-    rsaPublicKeyGeneration(privateKeyPem: string): string | Buffer<ArrayBufferLike>;
+    }>;
+    rsaPublicKeyGeneration(privateKeyPem: string): Promise<string | Buffer<ArrayBufferLike>>;
 }

package/dist/{crypto/node.crypto.js → runtime/node.runtime.js}

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,6 +40,12 @@ exports.NodeCrypto = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const functions_lib_1 = require("../lib/functions.lib");
 class NodeCrypto {
+    crypto;
+    async __init() {
+        if (!this.crypto) {
+            return await Promise.resolve().then(() => __importStar(require('crypto')));
+        }
+    }
     _encrypt(algorithm, key, payload) {
         const iv = crypto_1.default.randomBytes(12);
         const cipher = crypto_1.default.createCipheriv(algorithm, key, iv);
@@ -51,8 +90,9 @@ class NodeCrypto {
         });
         return { privateKey, publicKey };
     }
-    encrypt(algo, key, payload, exp) {
-        const keyHash = crypto_1.default.createHash('sha256').update(key).digest();
+    async encrypt(algo, key, payload, exp) {
+        await this.__init();
+        const keyHash = this.crypto.createHash('sha256').update(key).digest();
         const newPayload = { payload: payload, exp: exp };
         const { iv, encrypted, tag } = this._encrypt(algo, keyHash, newPayload);
         return (0, functions_lib_1.tokenFormatCreate)({
@@ -64,11 +104,13 @@ class NodeCrypto {
             tag
         }, encrypted);
     }
-    decrypt(algo, key, encryptedData) {
+    async decrypt(algo, key, encryptedData) {
+        await this.__init();
         const keyHash = crypto_1.default.createHash('sha256').update(key).digest();
         return this._decrypt(algo, keyHash, encryptedData);
     }
-    encryptRSA(payload, publicKey, exp) {
+    async encryptRSA(payload, publicKey, exp) {
+        await this.__init();
         const symmetricKey = crypto_1.default.randomBytes(32);
         const newPayload = { payload: payload, exp: exp };
         const { iv, encrypted, tag } = this._encrypt('aes-256-gcm', symmetricKey, newPayload);
@@ -87,7 +129,8 @@ class NodeCrypto {
             encryptedKey: encryptedSymmetricKey.toString('base64')
         }, encrypted);
     }
-    decryptRSA(privateKey, encryptedKey, encryptedData) {
+    async decryptRSA(privateKey, encryptedKey, encryptedData) {
+        await this.__init();
         const decryptedSymmetricKey = crypto_1.default.privateDecrypt({
             key: privateKey,
             padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
@@ -95,10 +138,12 @@ class NodeCrypto {
         }, Buffer.from(encryptedKey, 'base64'));
         return this._decrypt('aes-256-gcm', decryptedSymmetricKey, encryptedData);
     }
-    rsaPrivatePublicKeyGeneration() {
+    async rsaPrivatePublicKeyGeneration() {
+        await this.__init();
         return this._rsaPrivatePublicKeyGeneration();
     }
-    rsaPublicKeyGeneration(privateKeyPem) {
+    async rsaPublicKeyGeneration(privateKeyPem) {
+        await this.__init();
         return this._rsaPublicKeyGeneration(privateKeyPem);
     }
 }

package/dist/{crypto/crypto.d.ts → runtime/runtime.d.ts}

@@ -1,4 +1,4 @@
-export declare class Crypto {
+export declare class RuntimeCrypto {
     private node;
     private web;
     private getModule;

package/dist/{crypto/crypto.js → runtime/runtime.js}

@@ -33,23 +33,23 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Crypto = void 0;
+exports.RuntimeCrypto = void 0;
 const algo_config_1 = require("../config/algo.config");
 const functions_lib_1 = require("../lib/functions.lib");
-class Crypto {
+class RuntimeCrypto {
     node;
     web;
     async getModule(runtime) {
         if (runtime === 'node' && this.node === undefined) {
-            const { NodeCrypto } = await Promise.resolve().then(() => __importStar(require('./node.crypto')));
+            const { NodeCrypto } = await Promise.resolve().then(() => __importStar(require('./node.runtime')));
             this.node = new NodeCrypto();
         }
         else if (runtime === 'web' && this.web === undefined) {
-            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.crypto')));
+            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.runtime')));
             this.web = new WebCrypto();
         }
         else if (runtime === 'edge' && this.web === undefined) {
-            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.crypto')));
+            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.runtime')));
             this.web = new WebCrypto();
         }
     }
@@ -65,13 +65,13 @@ class Crypto {
                 if (algoData.value !== 'ras+a256gcm') {
                     throw new Error(`Algorithm ${algoData.name} is not supported for asymmetric encryption`);
                 }
-                return this.node.encryptRSA(payload, key, exp);
+                return await this.node.encryptRSA(payload, key, exp);
             }
             else {
                 if (algoData.value !== 'aes-256-gcm') {
                     throw new Error(`Algorithm ${algoData.name} is not supported for symmetric encryption`);
                 }
-                return this.node.encrypt(algoData.value, key, payload, exp);
+                return await this.node.encrypt(algoData.value, key, payload, exp);
             }
         }
         else {
@@ -101,13 +101,13 @@ class Crypto {
                 if (algo !== 'RSA+A256GCM') {
                     throw new Error(`Algorithm ${algo} is not supported for asymmetric encryption`);
                 }
-                return this.node.decryptRSA(key, encryptedKey, { iv, encrypted, tag });
+                return await this.node.decryptRSA(key, encryptedKey, { iv, encrypted, tag });
             }
             else {
                 if (algo !== 'AES-256-GCM') {
                     throw new Error(`Algorithm ${algo} is not supported for symmetric encryption`);
                 }
-                return this.node.decrypt("aes-256-gcm", key, { iv, encrypted, tag });
+                return await this.node.decrypt("aes-256-gcm", key, { iv, encrypted, tag });
             }
         }
         else {
@@ -129,12 +129,12 @@ class Crypto {
         await this.getModule(runtime);
         if (runtime === 'node') {
             if (type === 'keyPair') {
-                return this.node.rsaPrivatePublicKeyGeneration();
+                return await this.node.rsaPrivatePublicKeyGeneration();
             }
             else {
                 if (!privateKeyPem)
                     throw new Error('privateKeyPem is required');
-                return this.node.rsaPublicKeyGeneration(privateKeyPem);
+                return await this.node.rsaPublicKeyGeneration(privateKeyPem);
             }
         }
         else {
@@ -149,4 +149,4 @@ class Crypto {
         }
     }
 }
-exports.Crypto = Crypto;
+exports.RuntimeCrypto = RuntimeCrypto;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsonauthtoken",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "jsonauthtoken is a JavaScript/TypeScript library to secure authentication.",
   "main": "dist/index.js",
   "repository": {