jsonauthtoken 2.0.0 → 3.0.0

package/README.md

@@ -4,7 +4,7 @@ jsonauthtoken is a JavaScript library to secure authentication.
 
 ## Overview
 
-This project demonstrates the usage of the `jsonauthtoken` package to create and verify secure encrypted authentication tokens and store sensitive datas. Tokens are used to sign and encrypt data for secure communication. The `jsonauthtoken` library provides methods to generate and verify tokens with configurable expiration times, hashing algorithms, and payload data.
+This project demonstrates the usage of the `jsonauthtoken` package to create and verify secure encrypted authentication tokens and store sensitive datas. Tokens are used to encrypt data for secure communication. The `jsonauthtoken` library provides methods to generate and verify tokens with configurable expiration times, encryption algorithms, payload data and also offer key generation.
 
 
 ## Node.js (Install)
@@ -20,47 +20,26 @@ npm install jsonauthtoken
 
 ### Usage
 
-To create jsonauthtoken:
 
 ```javascript
-import jat from "jsonauthtoken";
-
-// Create a token
-let encToken = jat().create(
-    {
-        signKey: process.env.SIGN_KEY, // Signature key
-        encKey: process.env.ENC_KEY   // Encryption key
-    },
-    {
-        expiresAt: '4MIN',            // Token expiration time
-        algorithm: 'sha256'           // Optional: Hash algorithms list ['sha256', 'sha384', 'sha512'] 
-    },
-    {
-        data: {                       // Data payload
-            status: true,
-            name:'Arpan Biswas',
-            dob: '15.11.2008'
-        }
-    }
-);
-
-console.log("encToken: ", encToken);
+import { JAT } from "jsonauthtoken";
 
-```
+(async () => {
+    
+    const jat = JAT()
 
-To decrypt and verify jsonauthtoken:
+    const payload = {
+        name: 'jsonauthtoken'
+    } as const
 
-```javascript
-import jat from "jsonauthtoken";
+    //to create token
+    const token = await jat.create({ key: process.env.KEY }, payload)
 
-// Decrypt and verify jsonauthtoken
+    //to verify token
+    const verify =await jat.verify<typeof payload>(token, process.env.KEY)
 
-let token = 'your-token-here';  // Replace with your generated token
-let datas = jat().verify(token, {
-    signKey: process.env.SIGN_KEY, // Signature key
-    encKey: process.env.ENC_KEY    // Encryption key
-});
+    console.log(verify)
 
-console.log("Enc Data: ", datas);
+})()
 
 ```

package/dist/config/algo.config.d.ts

@@ -0,0 +1,2 @@
+export declare const SUPPORTED_ALGORITHM: Record<Runtime, AlgorithmDetails[]>;
+export declare const DEFAULT_ALGORITHM: Record<Runtime, AlgorithmDetails[]>;

package/dist/config/algo.config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ALGORITHM = exports.SUPPORTED_ALGORITHM = void 0;
+exports.SUPPORTED_ALGORITHM = {
+    node: [
+        { name: 'AES-256-GCM', value: 'aes-256-gcm', type: 'symmetric' },
+        { name: 'RSA+A256GCM', value: 'rsa+a256gcm', type: 'asymmetric' },
+    ],
+    web: [
+        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
+        { name: 'RSA+AES-GCM', value: 'RSA+AES-GCM', type: 'asymmetric' }
+    ],
+    edge: [
+        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
+        { name: 'RSA+AES-GCM', value: 'RSA+AES-GCM', type: 'asymmetric' }
+    ]
+};
+exports.DEFAULT_ALGORITHM = {
+    node: [
+        { name: 'AES-256-GCM', value: 'aes-256-gcm', type: 'symmetric' },
+    ],
+    web: [
+        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
+    ],
+    edge: [
+        { name: 'AES-GCM', value: 'AES-GCM', type: 'symmetric' },
+    ]
+};

package/dist/config/name.config.d.ts

@@ -0,0 +1 @@
+export declare const RUNTIME: Runtime[];

package/dist/config/name.config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME = void 0;
+exports.RUNTIME = ['node', 'edge', 'web'];

package/dist/config/runtime.config.d.ts

@@ -0,0 +1 @@
+export declare function detectRuntime(): Runtime;

package/dist/config/runtime.config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRuntime = detectRuntime;
+function detectRuntime() {
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        return 'node';
+    }
+    if (typeof window !== 'undefined' && window.crypto?.subtle) {
+        return 'web';
+    }
+    if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
+        return 'edge';
+    }
+    return 'node';
+}

package/dist/crypto/crypto.d.ts

@@ -0,0 +1,12 @@
+export declare class Crypto {
+    private node;
+    private web;
+    private getModule;
+    createToken(runtime: Runtime, algo: string, key: string, payload: any, exp: number): Promise<string>;
+    verifyToken<T>(currentRuntime: Runtime, token: string, key: string): Promise<{
+        payload: T;
+        exp: number;
+    }>;
+    rsaKeyDrivation(runtime: Runtime, type: 'keyPair'): Promise<GenerateKeyPair>;
+    rsaKeyDrivation(runtime: Runtime, type: 'publickey', privateKeyPem: string): Promise<string>;
+}

package/dist/crypto/crypto.js

@@ -0,0 +1,152 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crypto = void 0;
+const algo_config_1 = require("../config/algo.config");
+const functions_lib_1 = require("../lib/functions.lib");
+class Crypto {
+    node;
+    web;
+    async getModule(runtime) {
+        if (runtime === 'node' && this.node === undefined) {
+            const { NodeCrypto } = await Promise.resolve().then(() => __importStar(require('./node.crypto')));
+            this.node = new NodeCrypto();
+        }
+        else if (runtime === 'web' && this.web === undefined) {
+            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.crypto')));
+            this.web = new WebCrypto();
+        }
+        else if (runtime === 'edge' && this.web === undefined) {
+            const { WebCrypto } = await Promise.resolve().then(() => __importStar(require('./web.crypto')));
+            this.web = new WebCrypto();
+        }
+    }
+    async createToken(runtime, algo, key, payload, exp) {
+        const algorithms = algo_config_1.SUPPORTED_ALGORITHM[runtime];
+        const algoData = algorithms.find(({ name }) => { return name == algo; });
+        if (!algoData) {
+            throw new Error(`Algorithm ${algo} is not supported for ${runtime}`);
+        }
+        await this.getModule(runtime);
+        if (runtime === 'node') {
+            if (algoData.type === 'asymmetric') {
+                if (algoData.value !== 'ras+a256gcm') {
+                    throw new Error(`Algorithm ${algoData.name} is not supported for asymmetric encryption`);
+                }
+                return 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);
+            }
+        }
+        else {
+            if (algoData.type === 'asymmetric') {
+                if (algoData.value !== 'RSA+AES-GCM') {
+                    throw new Error(`Algorithm ${algoData.name} is not supported for asymmetric encryption`);
+                }
+                return await this.web.encryptRSA(payload, key, exp);
+            }
+            else {
+                if (algoData.value !== 'AES-GCM') {
+                    throw new Error(`Algorithm ${algoData.name} is not supported for symmetric encryption`);
+                }
+                return await this.web.encrypt(algoData.value, key, payload, exp);
+            }
+        }
+    }
+    async verifyToken(currentRuntime, token, key) {
+        const { meta, encrypted } = (0, functions_lib_1.tokenFormatVerify)(token);
+        const { runtime, algo, type, v, iv, tag, encryptedKey } = meta;
+        if (currentRuntime !== runtime) {
+            throw new Error('Runtime not matching');
+        }
+        await this.getModule(runtime);
+        if (runtime === 'node') {
+            if (type === 'asymmetric') {
+                if (algo !== 'RSA+A256GCM') {
+                    throw new Error(`Algorithm ${algo} is not supported for asymmetric encryption`);
+                }
+                return 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 });
+            }
+        }
+        else {
+            if (type === 'asymmetric') {
+                if (algo !== 'RSA+AES-GCM') {
+                    throw new Error(`Algorithm ${algo} is not supported for asymmetric encryption`);
+                }
+                return await this.web.decryptRSA(key, encryptedKey, { iv, encrypted });
+            }
+            else {
+                if (algo !== 'AES-GCM') {
+                    throw new Error(`Algorithm ${algo} is not supported for symmetric encryption`);
+                }
+                return await this.web.decrypt('AES-GCM', key, { iv, encrypted });
+            }
+        }
+    }
+    async rsaKeyDrivation(runtime, type, privateKeyPem) {
+        await this.getModule(runtime);
+        if (runtime === 'node') {
+            if (type === 'keyPair') {
+                return this.node.rsaPrivatePublicKeyGeneration();
+            }
+            else {
+                if (!privateKeyPem)
+                    throw new Error('privateKeyPem is required');
+                return this.node.rsaPublicKeyGeneration(privateKeyPem);
+            }
+        }
+        else {
+            if (type === 'keyPair') {
+                return await this.web.rsaPrivatePublicKeyGeneration();
+            }
+            else {
+                if (!privateKeyPem)
+                    throw new Error('privateKeyPem is required');
+                return await this.web.rsaPublicKeyGeneration(privateKeyPem);
+            }
+        }
+    }
+}
+exports.Crypto = Crypto;

package/dist/crypto/node.crypto.d.ts

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

package/dist/crypto/node.crypto.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCrypto = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const functions_lib_1 = require("../lib/functions.lib");
+class NodeCrypto {
+    _encrypt(algorithm, key, payload) {
+        const iv = crypto_1.default.randomBytes(12);
+        const cipher = crypto_1.default.createCipheriv(algorithm, key, iv);
+        const data = JSON.stringify(payload);
+        let encrypted = cipher.update(data, 'utf8', 'base64');
+        encrypted += cipher.final('base64');
+        const tag = cipher.getAuthTag().toString('base64');
+        return {
+            iv: iv.toString('base64'),
+            encrypted,
+            tag
+        };
+    }
+    _decrypt(algorithm, key, encryptedData) {
+        const { iv, encrypted, tag } = encryptedData;
+        const decipher = crypto_1.default.createDecipheriv(algorithm, key, Buffer.from(iv, 'base64'));
+        decipher.setAuthTag(Buffer.from(tag, 'base64'));
+        let decrypted = decipher.update(encrypted, 'base64', 'utf8');
+        decrypted += decipher.final('utf8');
+        return JSON.parse(decrypted);
+    }
+    _rsaPublicKeyGeneration(privateKeyPem) {
+        const privateKeyObject = crypto_1.default.createPrivateKey({
+            key: privateKeyPem.replace(/\\n/g, '\n'),
+            format: 'pem',
+            type: 'pkcs8'
+        });
+        const publicKeyObject = crypto_1.default.createPublicKey(privateKeyObject);
+        return publicKeyObject.export({ type: 'spki', format: 'pem' });
+    }
+    _rsaPrivatePublicKeyGeneration() {
+        const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync('rsa', {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem'
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem'
+            }
+        });
+        return { privateKey, publicKey };
+    }
+    encrypt(algo, key, payload, exp) {
+        const keyHash = crypto_1.default.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)({
+            runtime: 'node',
+            algo: 'AES-256-GCM',
+            type: 'symmetric',
+            v: '1',
+            iv,
+            tag
+        }, encrypted);
+    }
+    decrypt(algo, key, encryptedData) {
+        const keyHash = crypto_1.default.createHash('sha256').update(key).digest();
+        return this._decrypt(algo, keyHash, encryptedData);
+    }
+    encryptRSA(payload, publicKey, exp) {
+        const symmetricKey = crypto_1.default.randomBytes(32);
+        const newPayload = { payload: payload, exp: exp };
+        const { iv, encrypted, tag } = this._encrypt('aes-256-gcm', symmetricKey, newPayload);
+        const encryptedSymmetricKey = crypto_1.default.publicEncrypt({
+            key: publicKey,
+            padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256'
+        }, symmetricKey);
+        return (0, functions_lib_1.tokenFormatCreate)({
+            runtime: 'node',
+            algo: 'RSA+A256GCM',
+            type: 'asymmetric',
+            v: '1',
+            iv,
+            tag,
+            encryptedKey: encryptedSymmetricKey.toString('base64')
+        }, encrypted);
+    }
+    decryptRSA(privateKey, encryptedKey, encryptedData) {
+        const decryptedSymmetricKey = crypto_1.default.privateDecrypt({
+            key: privateKey,
+            padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256'
+        }, Buffer.from(encryptedKey, 'base64'));
+        return this._decrypt('aes-256-gcm', decryptedSymmetricKey, encryptedData);
+    }
+    rsaPrivatePublicKeyGeneration() {
+        return this._rsaPrivatePublicKeyGeneration();
+    }
+    rsaPublicKeyGeneration(privateKeyPem) {
+        return this._rsaPublicKeyGeneration(privateKeyPem);
+    }
+}
+exports.NodeCrypto = NodeCrypto;

package/dist/crypto/web.crypto.d.ts

@@ -0,0 +1,38 @@
+export declare class WebCrypto {
+    private textEncoder;
+    private textDecoder;
+    private __importAESKey;
+    private __uint8ArrayToBase64;
+    private __base64ToUint8Array;
+    private __arrayBufferToBase64;
+    private __base64ToArrayBuffer;
+    private __pemToArrayBuffer;
+    private __arrayBufferToPem;
+    private __importPublicKey;
+    private __importPrivateKey;
+    private _encrypt;
+    private _decrypt;
+    private _rsaPublicKeyGeneration;
+    private _rsaPrivatePublicKeyGeneration;
+    encrypt(algo: 'AES-GCM', key: string, payload: any, exp: number): Promise<string>;
+    decrypt<T>(algo: 'AES-GCM', key: string, encryptedData: {
+        iv: string;
+        encrypted: string;
+    }): Promise<{
+        payload: T;
+        exp: number;
+    }>;
+    encryptRSA(payload: any, publicKeyPem: string, exp: number): Promise<string>;
+    decryptRSA<T>(privateKeyPem: string, encryptedKey: string, encryptedData: {
+        iv: string;
+        encrypted: string;
+    }): Promise<{
+        payload: T;
+        exp: number;
+    }>;
+    rsaPrivatePublicKeyGeneration(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    rsaPublicKeyGeneration(privateKeyPem: string): Promise<string>;
+}

package/dist/crypto/web.crypto.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCrypto = void 0;
+const functions_lib_1 = require("../lib/functions.lib");
+class WebCrypto {
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
+    async __importAESKey(password) {
+        const passwordBuffer = this.textEncoder.encode(password);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', passwordBuffer);
+        return await crypto.subtle.importKey('raw', hashBuffer, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
+    }
+    __uint8ArrayToBase64(uint8Array) {
+        let binary = '';
+        const len = uint8Array.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(uint8Array[i]);
+        }
+        return btoa(binary);
+    }
+    __base64ToUint8Array(base64) {
+        const binaryString = atob(base64);
+        const len = binaryString.length;
+        const bytes = new Uint8Array(len);
+        for (let i = 0; i < len; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes;
+    }
+    __arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    __base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+    __pemToArrayBuffer(pem, type) {
+        const pemHeader = `-----BEGIN ${type} KEY-----`;
+        const pemFooter = `-----END ${type} KEY-----`;
+        const pemContents = pem
+            .replace(pemHeader, '')
+            .replace(pemFooter, '')
+            .replace(/\\n/g, '')
+            .replace(/\s/g, '');
+        return this.__base64ToArrayBuffer(pemContents);
+    }
+    __arrayBufferToPem(buffer, type) {
+        const base64 = this.__arrayBufferToBase64(buffer);
+        const pemContents = base64.match(/.{1,64}/g)?.join('\n') || base64;
+        return `-----BEGIN ${type} KEY-----\n${pemContents}\n-----END ${type} KEY-----`;
+    }
+    async __importPublicKey(publicKeyPem) {
+        const keyData = this.__pemToArrayBuffer(publicKeyPem, 'PUBLIC');
+        return await crypto.subtle.importKey('spki', keyData, {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256'
+        }, true, ['encrypt']);
+    }
+    async __importPrivateKey(privateKeyPem) {
+        const keyData = this.__pemToArrayBuffer(privateKeyPem.replace(/\\n/g, '\n'), 'PRIVATE');
+        return await crypto.subtle.importKey('pkcs8', keyData, {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256'
+        }, true, ['decrypt']);
+    }
+    async _encrypt(algo, key, payload) {
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const data = this.textEncoder.encode(JSON.stringify(payload));
+        const encryptedBuffer = await crypto.subtle.encrypt({
+            name: algo,
+            iv: iv,
+            tagLength: 128
+        }, key, data);
+        const encryptedBytes = new Uint8Array(encryptedBuffer);
+        return {
+            iv: this.__uint8ArrayToBase64(iv),
+            encrypted: this.__uint8ArrayToBase64(encryptedBytes),
+        };
+    }
+    async _decrypt(algo, key, encryptedData) {
+        const { iv, encrypted } = encryptedData;
+        const ivBuffer = this.__base64ToUint8Array(iv);
+        const encryptedBuffer = this.__base64ToUint8Array(encrypted);
+        const decryptedBuffer = await crypto.subtle.decrypt({
+            name: algo,
+            iv: ivBuffer,
+            tagLength: 128
+        }, key, encryptedBuffer);
+        return JSON.parse(this.textDecoder.decode(decryptedBuffer));
+    }
+    async _rsaPublicKeyGeneration(privateKeyPem) {
+        const privateKey = await this.__importPrivateKey(privateKeyPem);
+        const jwk = await crypto.subtle.exportKey('jwk', privateKey);
+        delete jwk.d;
+        delete jwk.dp;
+        delete jwk.dq;
+        delete jwk.q;
+        delete jwk.qi;
+        jwk.key_ops = ['encrypt'];
+        const publicKey = await crypto.subtle.importKey('jwk', jwk, {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256'
+        }, true, ['encrypt']);
+        const exportedPublicKey = await crypto.subtle.exportKey('spki', publicKey);
+        return this.__arrayBufferToPem(exportedPublicKey, 'PUBLIC');
+    }
+    async _rsaPrivatePublicKeyGeneration() {
+        const keyPair = await crypto.subtle.generateKey({
+            name: 'RSA-OAEP',
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: 'SHA-256'
+        }, true, ['encrypt', 'decrypt']);
+        const privateKeyBuffer = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
+        const publicKeyBuffer = await crypto.subtle.exportKey('spki', keyPair.publicKey);
+        return {
+            privateKey: this.__arrayBufferToPem(privateKeyBuffer, 'PRIVATE'),
+            publicKey: this.__arrayBufferToPem(publicKeyBuffer, 'PUBLIC')
+        };
+    }
+    async encrypt(algo, key, payload, exp) {
+        const cryptoKey = await this.__importAESKey(key);
+        const newPayload = { payload: payload, exp: exp };
+        const { iv, encrypted } = await this._encrypt(algo, cryptoKey, newPayload);
+        return (0, functions_lib_1.tokenFormatCreate)({
+            runtime: 'web',
+            algo: 'AES-GCM',
+            type: 'symmetric',
+            v: '1',
+            iv,
+        }, encrypted);
+    }
+    async decrypt(algo, key, encryptedData) {
+        const cryptoKey = await this.__importAESKey(key);
+        return await this._decrypt(algo, cryptoKey, encryptedData);
+    }
+    async encryptRSA(payload, publicKeyPem, exp) {
+        const symmetricKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
+        const newPayload = { payload: payload, exp: exp };
+        const { iv, encrypted } = await this._encrypt('AES-GCM', symmetricKey, newPayload);
+        const symmetricKeyBuffer = await crypto.subtle.exportKey('raw', symmetricKey);
+        const publicKey = await this.__importPublicKey(publicKeyPem);
+        const encryptedSymmetricKey = await crypto.subtle.encrypt({
+            name: 'RSA-OAEP'
+        }, publicKey, symmetricKeyBuffer);
+        return (0, functions_lib_1.tokenFormatCreate)({
+            runtime: 'web',
+            algo: 'RSA+AES-GCM',
+            type: 'asymmetric',
+            v: '1',
+            iv,
+            encryptedKey: this.__arrayBufferToBase64(encryptedSymmetricKey)
+        }, encrypted);
+    }
+    async decryptRSA(privateKeyPem, encryptedKey, encryptedData) {
+        const privateKey = await this.__importPrivateKey(privateKeyPem);
+        const encryptedKeyBuffer = this.__base64ToArrayBuffer(encryptedKey);
+        const decryptedSymmetricKeyBuffer = await crypto.subtle.decrypt({
+            name: 'RSA-OAEP'
+        }, privateKey, encryptedKeyBuffer);
+        const symmetricKey = await crypto.subtle.importKey('raw', decryptedSymmetricKeyBuffer, { name: 'AES-GCM' }, false, ['decrypt']);
+        return await this._decrypt('AES-GCM', symmetricKey, encryptedData);
+    }
+    async rsaPrivatePublicKeyGeneration() {
+        return await this._rsaPrivatePublicKeyGeneration();
+    }
+    async rsaPublicKeyGeneration(privateKeyPem) {
+        return await this._rsaPublicKeyGeneration(privateKeyPem);
+    }
+}
+exports.WebCrypto = WebCrypto;

package/dist/index.d.ts

@@ -1,5 +1,34 @@
-declare function jat(): {
-    create: (keys: KeysType, headers?: HeaderForCreate, payloads?: any) => string;
-    verify: (encryptedToken: string, keys: KeysType) => HeaderAndPlayload;
+declare class JATClass<R extends Runtime = Runtime> {
+    private runtime;
+    private dev;
+    private crypto;
+    constructor(config?: JATConfig<R>);
+    create(header: CreateTokenConfig<R>, payload: any): Promise<string>;
+    verify<T>(token: string, key: string): Promise<T>;
+}
+export declare const JAT: <R extends Runtime = Runtime>(config?: JATConfig<R>) => JATClass<R>;
+export declare const getSupportedAlgorithm: () => Record<Runtime, AlgorithmDetails[]>;
+export declare const P2KG: {
+    generateKeyPair: (options?: {
+        runtime?: Runtime;
+        dev?: boolean;
+    }) => Promise<GenerateKeyPair>;
+    generatePublicKey: (privateKeyPem: string, options?: {
+        runtime?: Runtime;
+        dev?: boolean;
+    }) => Promise<string>;
 };
-export default jat;
+declare const jsonauthtoken: {
+    JAT: <R extends Runtime = Runtime>(config?: JATConfig<R>) => JATClass<R>;
+    P2KG: {
+        generateKeyPair: (options?: {
+            runtime?: Runtime;
+            dev?: boolean;
+        }) => Promise<GenerateKeyPair>;
+        generatePublicKey: (privateKeyPem: string, options?: {
+            runtime?: Runtime;
+            dev?: boolean;
+        }) => Promise<string>;
+    };
+};
+export default jsonauthtoken;

package/dist/index.js

@@ -1,68 +1,133 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const encoading_lib_1 = __importDefault(require("./lib/encoading.lib"));
-const decoading_lib_1 = __importDefault(require("./lib/decoading.lib"));
-const signature_lib_1 = __importDefault(require("./lib/signature.lib"));
-const encryption_lib_1 = __importDefault(require("./lib/encryption.lib"));
-const decryption_lib_1 = __importDefault(require("./lib/decryption.lib"));
+exports.P2KG = exports.getSupportedAlgorithm = exports.JAT = void 0;
+const name_config_1 = require("./config/name.config");
+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 algorithms = ['sha256', 'sha384', 'sha512'];
-function jat() {
-    const create = (keys, headers = {}, payloads = {}) => {
-        let { signKey, encKey } = keys;
-        if (!signKey)
-            throw new Error("please provide signkey");
-        if (!encKey)
-            throw new Error("please provide encKey");
-        let exp;
-        if (headers.expiresAt)
-            exp = (0, functions_lib_1.parseExpiration)(headers.expiresAt);
-        else
-            throw new Error("please provide token expire");
-        let algo = (0, functions_lib_1.algoMatching)(algorithms, 'sha512', headers.algorithm);
-        let header = (0, encoading_lib_1.default)({
-            token: 'JAT',
-            algorithm: algo,
-            createAt: Math.floor(Date.now() / 1000),
-            expiresAt: exp,
-        });
-        if (typeof (payloads) != 'object')
-            throw new Error("payload should be Object");
-        let payload = (0, encoading_lib_1.default)(payloads);
-        let sign = (0, signature_lib_1.default)().createSign(algo, signKey, header, payload);
-        let token = header + '.' + payload + '.' + sign;
-        let encryptedToken = (0, encryption_lib_1.default)(encKey, token);
-        return encryptedToken;
-    };
-    const verify = (encryptedToken, keys) => {
-        let token = '';
-        let header;
-        let payload = '';
-        let { signKey, encKey } = keys;
-        if (!signKey)
-            throw new Error("please provide signkey");
-        if (!encKey)
-            throw new Error("please provide encKey");
+const timeformat_1 = require("./lib/timeformat");
+const crypto_1 = require("./crypto/crypto");
+class JATClass {
+    runtime;
+    dev = false;
+    crypto = new crypto_1.Crypto();
+    constructor(config) {
+        try {
+            if (config && config.dev == true)
+                this.dev = true;
+            if (config && config.runtime) {
+                if (!name_config_1.RUNTIME.includes(config.runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                this.runtime = config.runtime;
+            }
+            else {
+                this.runtime = (0, runtime_config_1.detectRuntime)();
+            }
+            (0, functions_lib_1.print)({ dev: this.dev }, 'Current Runtime: ', this.runtime);
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
+        }
+    }
+    async create(header, payload) {
         try {
-            token = (0, decryption_lib_1.default)(encryptedToken, encKey);
+            if (!header.key) {
+                throw new Error('key is required to create token');
+            }
+            const key = header.key;
+            const exp = header.exp ? (0, timeformat_1.jatTimeFormatter)(header.exp) : (0, timeformat_1.jatTimeFormatter)('5MIN');
+            const algo = header.algo || (algo_config_1.DEFAULT_ALGORITHM[this.runtime][0].name);
+            return await this.crypto.createToken(this.runtime, algo, key, payload, exp);
         }
         catch (error) {
-            throw new Error('unable to decrypt token');
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
         }
-        const [encodedHeader, encodedPayload, sign] = token.split('.');
-        let isSignVerified = (0, signature_lib_1.default)().verifySign({ encodedHeader, encodedPayload, sign }, signKey);
-        if (isSignVerified === false) {
-            throw new Error('Invalid signature');
+    }
+    async verify(token, key) {
+        try {
+            if (!token) {
+                throw new Error('Token is required to verify token');
+            }
+            if (!key) {
+                throw new Error('key is required to verify token');
+            }
+            const unfilterPayload = await this.crypto.verifyToken(this.runtime, token, key);
+            if ((0, functions_lib_1.isExpired)(unfilterPayload.exp)) {
+                throw new Error('Token expired');
+            }
+            return unfilterPayload.payload;
         }
-        header = (0, decoading_lib_1.default)(encodedHeader);
-        if ((0, functions_lib_1.isExpired)(header.expiresAt))
-            throw new Error('token is expired');
-        payload = (0, decoading_lib_1.default)(encodedPayload);
-        return { header, payload };
-    };
-    return { create, verify };
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: this.dev, color: 'red' }, error);
+            throw error;
+        }
+    }
 }
-exports.default = jat;
+class PrivatePublicKeyGeneration {
+    crypto = new crypto_1.Crypto();
+    async generateKeyPair(runtime, dev) {
+        let finalRuntime = (0, runtime_config_1.detectRuntime)();
+        const development = dev === true ? true : false;
+        try {
+            if (runtime) {
+                if (!name_config_1.RUNTIME.includes(runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                finalRuntime = runtime;
+            }
+            const { privateKey, publicKey } = await this.crypto.rsaKeyDrivation(finalRuntime, 'keyPair');
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, 'Current Runtime: ', finalRuntime);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, { privateKey, publicKey });
+            return { privateKey, publicKey };
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: development, color: 'red' }, error);
+            throw error;
+        }
+    }
+    async generatePublicKey(privateKeyPem, runtime, dev) {
+        let finalRuntime = (0, runtime_config_1.detectRuntime)();
+        const development = dev === true ? true : false;
+        try {
+            if (runtime) {
+                if (!name_config_1.RUNTIME.includes(runtime)) {
+                    throw new Error("Unsupported runtime");
+                }
+                finalRuntime = runtime;
+            }
+            const publicKey = await this.crypto.rsaKeyDrivation(finalRuntime, 'publickey', privateKeyPem);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, 'Current Runtime: ', finalRuntime);
+            (0, functions_lib_1.print)({ dev: development, color: 'green' }, publicKey);
+            return publicKey;
+        }
+        catch (error) {
+            (0, functions_lib_1.print)({ dev: development, color: 'red' }, error);
+            throw error;
+        }
+    }
+}
+const p2kgObject = new PrivatePublicKeyGeneration();
+const generateKeyPair = (options) => {
+    const { runtime, dev } = options || {};
+    return p2kgObject.generateKeyPair(runtime, dev);
+};
+const generatePublicKey = (privateKeyPem, options) => {
+    const { runtime, dev } = options || {};
+    return p2kgObject.generatePublicKey(privateKeyPem, runtime, dev);
+};
+const JAT = (config) => new JATClass(config);
+exports.JAT = JAT;
+const getSupportedAlgorithm = () => algo_config_1.SUPPORTED_ALGORITHM;
+exports.getSupportedAlgorithm = getSupportedAlgorithm;
+exports.P2KG = {
+    generateKeyPair: generateKeyPair,
+    generatePublicKey: generatePublicKey
+};
+const jsonauthtoken = {
+    JAT: exports.JAT,
+    P2KG: exports.P2KG
+};
+exports.default = jsonauthtoken;

package/dist/lib/functions.lib.d.ts

@@ -1,4 +1,12 @@
-declare function algoMatching(algorithms: AlgorithmArray, defaultOutput: Algorithm | string, input: string): string;
-declare function parseExpiration(input: string): number;
+declare function tokenFormatCreate<R extends Runtime = Runtime>(meta: TokenMetaData<R>, encrypted: string): string;
+declare function tokenFormatVerify<R extends Runtime = Runtime>(token: string): {
+    meta: TokenMetaData<R>;
+    encrypted: string;
+};
 declare function isExpired(timeStamp: number): boolean;
-export { algoMatching, parseExpiration, isExpired };
+type Color = 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white';
+declare function print({ dev, color }: {
+    dev?: boolean;
+    color?: Color;
+}, ...args: unknown[]): void;
+export { isExpired, tokenFormatCreate, tokenFormatVerify, print };

package/dist/lib/functions.lib.js

@@ -1,47 +1,57 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.algoMatching = algoMatching;
-exports.parseExpiration = parseExpiration;
 exports.isExpired = isExpired;
-function algoMatching(algorithms, defaultOutput, input) {
-    if (!defaultOutput)
-        throw new Error('defaultOutput parameter can not be empty');
-    let defaultAlgorithm = defaultOutput;
-    for (let i in algorithms) {
-        if (algorithms[i] === input)
-            defaultAlgorithm = algorithms[i];
-    }
-    return defaultAlgorithm.toString();
+exports.tokenFormatCreate = tokenFormatCreate;
+exports.tokenFormatVerify = tokenFormatVerify;
+exports.print = print;
+const algo_config_1 = require("../config/algo.config");
+const encoading_lib_1 = __importDefault(require("./encoading.lib"));
+const decoading_lib_1 = __importDefault(require("./decoading.lib"));
+const name_config_1 = require("../config/name.config");
+function tokenFormatCreate(meta, encrypted) {
+    return `${(0, encoading_lib_1.default)(meta)}:${encrypted}`;
 }
-function parseExpiration(input) {
-    const regex = /^(\d+)([mhdMHDyY]|MIN)$/;
-    const match = input.match(regex);
-    if (!match) {
-        throw new Error('Invalid format. Use formats like 1M, 1Y, 1D, 1MIN.');
-    }
-    const amount = parseInt(match[1], 10);
-    const unit = match[2].toLowerCase();
-    let seconds;
-    switch (unit) {
-        case 'y':
-            seconds = amount * 365 * 24 * 60 * 60;
-            break;
-        case 'm':
-            seconds = amount * 30 * 24 * 60 * 60;
-            break;
-        case 'd':
-            seconds = amount * 24 * 60 * 60;
-            break;
-        case 'h':
-            seconds = amount * 60 * 60;
-            break;
-        case 'min':
-            seconds = amount * 60;
-            break;
-        default:
-            throw new Error('Unsupported time unit. Use M, Y, D, H, or MIN.');
-    }
-    return Math.floor(Date.now() / 1000) + seconds;
+function tokenFormatVerify(token) {
+    const index = token.indexOf(":");
+    if (index === -1) {
+        throw new Error("Invalid token format");
+    }
+    const metaPart = token.substring(0, index);
+    const encryptedPart = token.substring(index + 1);
+    const meta = (0, decoading_lib_1.default)(metaPart);
+    if (!meta) {
+        throw new Error("Invalid token format");
+    }
+    const algorithm = algo_config_1.SUPPORTED_ALGORITHM[meta.runtime]?.find(e => e.name === meta.algo);
+    if (!algorithm) {
+        throw new Error("Invalid token format");
+    }
+    if (algorithm.type !== meta.type) {
+        throw new Error("Invalid token format");
+    }
+    if (meta.type === 'asymmetric') {
+        if (!meta.encryptedKey) {
+            throw new Error("Invalid token format");
+        }
+    }
+    if (!meta.iv) {
+        throw new Error("Invalid token format");
+    }
+    if (!name_config_1.RUNTIME.includes(meta.runtime)) {
+        throw new Error("Invalid token format");
+    }
+    if (meta.runtime === 'node') {
+        if (!meta.tag) {
+            throw new Error("Invalid token format");
+        }
+    }
+    if (!meta.v) {
+        throw new Error("Invalid token format");
+    }
+    return { meta, encrypted: encryptedPart };
 }
 function isExpired(timeStamp) {
     let currentTime = Math.floor(Date.now() / 1000);
@@ -52,3 +62,24 @@ function isExpired(timeStamp) {
         return false;
     }
 }
+function print({ dev = false, color = 'green' }, ...args) {
+    if (!dev)
+        return;
+    const colors = {
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m',
+        reset: '\x1b[0m',
+    };
+    if (typeof window !== 'undefined') {
+        console.log(`%c[jsonauthtoken]`, `color:${color}`, ...args);
+    }
+    else {
+        const colorCode = colors[color] ?? colors.green;
+        console.log(`${colorCode}[jsonauthtoken]`, ...args, '\x1b[0m');
+    }
+}

package/dist/lib/timeformat.d.ts

@@ -0,0 +1 @@
+export declare function jatTimeFormatter(input: JATTime): number;

package/dist/lib/timeformat.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jatTimeFormatter = jatTimeFormatter;
+function jatTimeFormatter(input) {
+    if (typeof input === 'number') {
+        if (input <= 0) {
+            throw new Error('Expiration time must be greater than zero.');
+        }
+        return Math.floor(Date.now() / 1000) + input;
+    }
+    const regex = /^(\d+)(S|MIN|H|D|M|Y)$/i;
+    const match = input.match(regex);
+    if (!match) {
+        throw new Error('Invalid format. Use number or formats like 1S, 1MIN, 1H, 1D, 1M, or 1Y.');
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2].toUpperCase();
+    let seconds;
+    switch (unit) {
+        case 'S':
+            seconds = amount;
+            break;
+        case 'MIN':
+            seconds = amount * 60;
+            break;
+        case 'H':
+            seconds = amount * 60 * 60;
+            break;
+        case 'D':
+            seconds = amount * 24 * 60 * 60;
+            break;
+        case 'M':
+            seconds = amount * 30 * 24 * 60 * 60;
+            break;
+        case 'Y':
+            seconds = amount * 365 * 24 * 60 * 60;
+            break;
+        default:
+            throw new Error(`Unsupported time unit: ${unit}`);
+    }
+    return Math.floor(Date.now() / 1000) + seconds;
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "jsonauthtoken",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "jsonauthtoken is a JavaScript/TypeScript library to secure authentication.",
   "main": "dist/index.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/iamAyanBiswas/jsonauthtoken"
+    "url": "git+https://github.com/iamAyanBiswas/jsonauthtoken.git"
   },
   "scripts": {
-    "test": "node dist/index.js",
-    "start": "tsc && node dist/index.js"
+    "build": "tsc",
+    "dev": "nodemon --watch src --ext ts --exec \"npm run build && node dist/test.js\""
   },
   "author": "Ayan Biswas",
   "license": "ISC",
@@ -27,9 +27,6 @@
     "jsonauthtoken",
     "jsonwebtoken",
     "auth",
-    "authentication",
-    "sha256",
-    "sha384",
-    "sha512"
+    "authentication"
   ]
-}
+}

package/types.d.ts

@@ -1,43 +1,67 @@
+import { RUNTIME } from "./src/config/name.config";
+
 declare global {
-    export type Algorithm = 'sha256' | 'sha384' | 'sha512';
-    export type AlgorithmArray = ['sha256', 'sha384', 'sha512']
 
-    //type for keys input 
-    interface KeysType {
-        signKey: string;
-        encKey: string;
+    type TimeUnit = 'S' | 'MIN' | 'H' | 'D' | 'M' | 'Y';
+    type ExpirationString = `${number}${TimeUnit}` | `${number}${Lowercase<TimeUnit>}`;
+    type JATTime = number | ExpirationString;
+
+    interface GenerateKeyPair {
+        privateKey: string
+        publicKey: string
     }
 
-    //type for header at create fn  
-    interface HeaderForCreate {
-        expiresAt?: string;
-        algorithm?: Algorithm;
+    type Runtime = 'node' | 'web' | 'edge';
+    type EncryptionAlgorithmType = 'symmetric' | 'asymmetric';
+
+    interface AlgorithmDetails {
+        name: string;
+        value: string
+        type: EncryptionAlgorithmType;
     }
 
-    //type for header at create fn 
-    interface HeaderForVerify {
-        expiresAt?: string;
-        algorithm?: Algorithm;
+    interface RuntimeWiseAlgorithmMap {
+        node: 'AES-256-GCM' | 'RSA+A256GCM'
+        edge: 'AES-GCM' | 'RSA+AES-GCM'
+        web: 'AES-GCM' | 'RSA+AES-GCM'
     }
 
-    //
-    interface DecryptedTokenParts {
-        encodedHeader: string;
-        encodedPayload: string;
-        sign: string
+    type RuntimeWiseAlgorithm<R extends Runtime> = RuntimeWiseAlgorithmMap[R];
+
+    interface JATConfig<R extends Runtime = Runtime> {
+        runtime?: R
+        dev?: boolean
     }
 
-    interface TokenHeaders {
-        token: 'JAT';
-        algorithm: string;
-        createAt: number;
-        expiresAt: number;
+    interface CreateTokenConfig<R extends Runtime> {
+        key: string
+        exp?: JATTime
+        algo?: RuntimeWiseAlgorithm<R>
     }
 
-    interface HeaderAndPlayload{
-        header:TokenHeaders;
-        payload:any
+    interface BaseTokenMetaData<R extends Runtime> {
+        runtime: Runtime;
+        algo: RuntimeWiseAlgorithm<R>;
+        v: string;
+        iv: string;
     }
+
+ type TokenMetaData<R extends Runtime> =
+  | (BaseTokenMetaData<R> & {
+      runtime: 'node';
+      tag: string;
+    } & (
+      | { type: 'symmetric'; encryptedKey?: never }
+      | { type: 'asymmetric'; encryptedKey: string }
+    ))
+  | (BaseTokenMetaData<R> & {
+      runtime: 'web' | 'edge';
+      tag?: never;
+    } & (
+      | { type: 'symmetric'; encryptedKey?: never }
+      | { type: 'asymmetric'; encryptedKey: string }
+    ));
+
 }
 
 export { };

package/dist/lib/decryption.lib.d.ts

@@ -1,2 +0,0 @@
-declare function decryption(encryptedToken: string, password: string): string;
-export default decryption;

package/dist/lib/decryption.lib.js

@@ -1,17 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto"));
-function decryption(encryptedToken, password) {
-    const parts = encryptedToken.split(':');
-    const iv = Buffer.from(parts.shift(), 'hex');
-    const encryptedTokenBuffer = Buffer.from(parts.join(':'), 'hex');
-    const key = crypto_1.default.scryptSync(password, 'salt', 32);
-    const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', key, iv);
-    let decrypted = decipher.update(encryptedTokenBuffer, null, 'utf8');
-    decrypted += decipher.final('utf8');
-    return decrypted;
-}
-exports.default = decryption;

package/dist/lib/encryption.lib.d.ts

@@ -1,2 +0,0 @@
-declare function encryption(password: string, token: string): string;
-export default encryption;

package/dist/lib/encryption.lib.js

@@ -1,15 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto"));
-function encryption(password, token) {
-    const iv = crypto_1.default.randomBytes(16);
-    const key = crypto_1.default.scryptSync(password, 'salt', 32);
-    const cipher = crypto_1.default.createCipheriv('aes-256-cbc', key, iv);
-    let encrypted = cipher.update(token, 'utf8', 'hex');
-    encrypted += cipher.final('hex');
-    return iv.toString('hex') + ':' + encrypted;
-}
-exports.default = encryption;

package/dist/lib/signature.lib.d.ts

@@ -1,5 +0,0 @@
-declare const signature: () => {
-    createSign: (algorithm: string, key: string, header: string, payload: string) => string;
-    verifySign: (tokens: DecryptedTokenParts, key: string) => boolean;
-};
-export default signature;

package/dist/lib/signature.lib.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto"));
-const decoading_lib_1 = __importDefault(require("./decoading.lib"));
-const signature = () => {
-    const createSign = (algorithm, key, header, payload) => {
-        const signature = crypto_1.default
-            .createHmac(algorithm, key)
-            .update(header + '.' + payload)
-            .digest('base64url');
-        return signature;
-    };
-    const verifySign = (tokens, key) => {
-        const header = (0, decoading_lib_1.default)(tokens.encodedHeader);
-        let newSign = createSign(header.algorithm, key, tokens.encodedHeader, tokens.encodedPayload);
-        if (newSign === tokens.sign)
-            return true;
-        else
-            return false;
-    };
-    return { createSign, verifySign };
-};
-exports.default = signature;