jsonauthtoken 3.0.1 → 3.0.2

package/dist/runtime/node.runtime.d.ts

@@ -1,30 +1,31 @@
 export declare class NodeCrypto {
-    constructor();
+    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/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,7 +40,11 @@ exports.NodeCrypto = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const functions_lib_1 = require("../lib/functions.lib");
 class NodeCrypto {
-    constructor() {
+    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);
@@ -53,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)({
@@ -66,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);
@@ -89,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,
@@ -97,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/runtime/runtime.js

@@ -65,13 +65,13 @@ class RuntimeCrypto {
                 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 RuntimeCrypto {
                 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 RuntimeCrypto {
         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 {

package/package.json

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