spliting

.github/workflows/main.yml

@@ -7,23 +7,22 @@ jobs:
   unit-test:
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     runs-on: ubuntu-latest
-    steps:    
+    steps:
       - uses: actions/checkout@v2
 
-      - name: Set up version 16
+      - name: Set up version 20.11.0
         uses: actions/setup-node@v1
         with:
-          node-version: 16
+          node-version: 20.11.0
 
       - name: Install dependencies
         run: npm install
 
       - name: Test
         run: npm run test
-      
+
       - name: Build package
         run: npm run build
 
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-

.github/workflows/publish.yml

@@ -7,22 +7,20 @@ jobs:
     # if: github.event_name == 'release' && github.event.action == 'published'
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout code        
+      - name: Checkout code
         uses: actions/checkout@main
-      - name: Node.js setup
+      - name: Node.js setup 20.11.0
         uses: actions/setup-node@v1
         with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/                        
-      - name: Install dependencies        
+          node-version: 20.11.0
+          registry-url: https://registry.npmjs.org/
+      - name: Install dependencies
         run: npm i
       - name: Test
         run: npm run test
       - name: Build package
-        run: npm run build 
+        run: npm run build
       - name: Publish package
         run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.PBKDF2_SECRET }}
-
-

.github/workflows/release-tag.yml

@@ -2,13 +2,13 @@ name: Create Release
 on:
   push:
     tags:
-      - 'v*' 
+      - 'v*'
 jobs:
-  release-tag:    
+  release-tag:
     if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
-    steps:      
-      - name: Set release version        
+    steps:
+      - name: Set release version
         uses: actions/checkout@master
       - name: Create Release for Tag
         id: create_release
@@ -22,6 +22,3 @@ jobs:
             Please refer to the [README](https://github.com/xkid1/pbkdf2.js/blob/main/README.md) for details.
           draft: false
           prerelease: false
-
-
-

README.md

@@ -15,31 +15,25 @@ Password-Based Key: This library provides the functionality, and required a pass
 ## Usage to encrypt and decrypt from frontend
 
 ```
-import JsPbkdf2 from 'js-pbkdf2';
+import { encrypt, decrypt } from 'js-pbkdf2';
 
-const jsPbkdf2 = new JsPbkdf2(crypto);
-
-const encrypt = await jsPbkdf2.encryptData('process.env.SECRET_KEY', JSON.stringify({example: 'example'}));
-
-const encrypt2 = await jsPbkdf2.encryptData('process.env.SECRET_KEY', 'sample string');
-
-const decrypt = await jsPbkdf2.decryptData('process.env.SECRET_KEY', 'WOwy8gEvHxEuLe0wl2A/cA==');
+const encrypted = await encrypt('secret password', JSON.stringify({example: 'example'}));
 
+const encrypt2 = await encrypt('secret password', 'sample string');
 
+const decrypted = await decrypt('secret password', 'WOwy8gEvHxEuLe0wl2A/cA==');
 ```
 
-
-
 ## Usage to encrypt and decrypt backend
 
 ```
-import JsPbkdf2 from 'js-pbkdf2';
-import {webcrypto} from 'crypto';
-const jsPbkdf2 = new JsPbkdf2(webcrypto);
+import { encrypt, decrypt } from 'js-pbkdf2';
+
+const encrypted = await encrypt('secret password', JSON.stringify({example: 'example'}));
 
-const encrypt = await jsPbkdf2.encryptData('process.env.SECRET_KEY', JSON.stringify({example: 'example'}));
+const encrypt2 = await encrypt('process.env.SECRET_KEY', 'sample string');
 
-const encrypt2 = await jsPbkdf2.encryptData('process.env.SECRET_KEY', 'sample string');
+const buf = await encrypt('process.env.SECRET_KEY', JSON.stringify({ id: 1, name: 'test', buffer: Buffer.from('hello'), typeArr: new Uint8Array([1, 2, 3]),}));
 
 const decrypt = await jsPbkdf2.decryptData('process.env.SECRET_KEY', 'WOwy8gEvHxEuLe0wl2A/cA==');
 
@@ -48,22 +42,18 @@ const decrypt = await jsPbkdf2.decryptData('process.env.SECRET_KEY', 'WOwy8gEvHx
 ## Sent http request
 
 ```
-import JsPbkdf2 from 'js-pbkdf2';
-
-const jsPbkdf2 = new JsPbkdf2(crypto);
+import { encrypt, decrypt } from 'js-pbkdf2';
 
-const encrypt = await jsPbkdf2.encryptData('process.env.SECRET_KEY', JSON.stringify({userName: 'example', password: 'sample'}));
+const encrypted = await encrypt('secret password', JSON.stringify({userName: 'example', password: 'sample'}));
 
 fetch('https://127.0.0.1/api/sample', {
     method: 'POST',
     headers: {
         'Content-Type': 'application/json',
         'Accept': 'application/json',
     },
-    body: JSON.stringify(encrypt),    
+    body: JSON.stringify(encrypted),    
 })
-
-
 ```
 
 ## Status

global.d.ts

@@ -2,37 +2,19 @@
  * PBKDF2 is a key derivation function that can be used to derive keys from a password.
  * It can be useda password based key derivation function (PBKDF2) or a password based key stretching function (PBKDF2-HMAC).
  * and it can be used from the frontend or the backend. to encrypt and decrypt data.
- * @function encryptFE - (Frontend) encrypt data with a password
- * @function decryptFE - (Frontend) decrypt data with a password
- * @function encryptBE - (Backend) encrypt data with a password
- * @function decryptBE - (Backend) decrypt data with a password
  */
 declare module 'js-pbkdf2' {
   /**
-   * encrypt data from (Frontend), return base64 string
+   * encrypt data and return base64 string
    * @param password - password must be required for encrypt and decrypt
    * @param data - The data must be Json string for encrypt
    */
-  function encryptFE(password: string, data: string): Promise<string>;
+  function encrypt(password: string, data: string): Promise<string>;
 
   /**
-   * decrypt data from (Frontend), return string
+   * decrypt data and return string
    * @param password - password must be required for decrypt
    * @param data - data for decrypt
    */
-  function decryptFE(password: string, data: string): Promise<string>;
-
-  /**
-   * encrypt data from (Backend), return base64 string
-   * @param password - password must be required for encrypt and decrypt
-   * @param data - The data must be Json string for encrypt
-   */
-  function encryptBE(password: string, data: string): Promise<string>;
-
-  /**
-   * decrypt data from (Backend), return string
-   * @param password - password must be required for decrypt
-   * @param data - data for decrypt
-   */
-  function decryptBE(password: string, data: string): Promise<string>;
+  function decrypt(password: string, data: string): Promise<string>;
 }

lib/helper.ts

@@ -83,6 +83,37 @@ class Helper extends Base {
       data
     );
   }
+
+  /**
+   * Begin to encrypt
+   *
+   * @param password
+   * @param data
+   * @returns {Promise<string>}
+   */
+  async processToEncrypt(password: string, data: string): Promise<string> {
+    const passkey = await this.passkey(password);
+    const aesKey = await this.aesKey(passkey);
+    const dataBuffer = this.instanceCommon.stringToBuffer(data);
+    const resultBuffer = await this.aesEncrypt(aesKey, dataBuffer);
+    return this.instanceCommon.bufferToBase64(resultBuffer);
+  }
+
+  /**
+   * Begin to decrypt
+   *
+   * @param decrypt
+   * @param data
+   * @returns {Promise<string>}
+   */
+  async processToDencrypt(password: string, data: string): Promise<string> {
+    const passkey = await this.passkey(password);
+    const aesKey = await this.aesKey(passkey);
+    const dataBuffer = this.instanceCommon.base64ToBuffer(data);
+    const resultBuffer = await this.aesDecrypt(aesKey, dataBuffer);
+
+    return this.instanceCommon.bufferToString(resultBuffer);
+  }
 }
 
 export default Helper;

src/index.ts

@@ -2,22 +2,20 @@ import PBKDF2BE from './js-pbkdf2-be';
 import JSPBKDF2FE from './js-pbkdf2-fe';
 
 interface InterfaceModulePackage {
-  encryptFE: Function;
-  decryptFE: Function;
-  encryptBE: Function;
-  decryptBE: Function;
+  encrypt: Function;
+  decrypt: Function;
 }
 
 const modulePackage = {} as InterfaceModulePackage;
 
 if (typeof window !== 'undefined') {
   const fe = new JSPBKDF2FE();
-  modulePackage.encryptFE = fe.encrypt;
-  modulePackage.decryptFE = fe.decrypt;
+  modulePackage.encrypt = fe.encrypt;
+  modulePackage.decrypt = fe.decrypt;
 } else {
   const be = new PBKDF2BE();
-  modulePackage.encryptBE = be.encrypt;
-  modulePackage.decryptBE = be.decrypt;
+  modulePackage.encrypt = be.encrypt;
+  modulePackage.decrypt = be.decrypt;
 }
 
 console.log('Module Package: ', modulePackage);

src/js-pbkdf2-be.ts

@@ -1,31 +1,19 @@
-import { Base, Helper, Common } from '../lib';
+import { Base, Helper } from '../lib';
 import { webcrypto } from 'crypto';
-
-/**
- * Class for backend
- */
-
 class PBKDF2BE extends Base {
   private instanceHelper: Helper;
-  private instanceCommon: Common;
-
   constructor() {
     super();
     this.instanceHelper = new Helper(
       webcrypto as Crypto,
       new Uint8Array(16).buffer,
       new Uint8Array(16).buffer
     );
-    this.instanceCommon = new Common();
   }
 
   /**
    * encrypt data, return base64 string
-   * @param password - password must be required for encrypt and decrypt
-   * @param data - The data must be string, json string
-   */
-  /**
-   * encrypt data, return base64 string
+   *
    * @param password - password must be required for encrypt and decrypt
    * @param data - The data must be string, json string
    * @returns {Promise<string>}
@@ -37,17 +25,9 @@ class PBKDF2BE extends Base {
     if (typeof password !== 'string' && typeof data !== 'string') {
       throw new Error('password and data must be string');
     }
-
     return new Promise(async (resolve, reject) => {
       try {
-        const passkey = await this.instanceHelper.passkey(password);
-        const aesKey = await this.instanceHelper.aesKey(passkey);
-        const dataBuffer = this.instanceCommon.stringToBuffer(data);
-        const resultBuffer = await this.instanceHelper.aesEncrypt(
-          aesKey,
-          dataBuffer
-        );
-        resolve(this.instanceCommon.bufferToBase64(resultBuffer));
+        resolve(await this.instanceHelper.processToEncrypt(password, data));
       } catch (error: any) {
         reject(error.message);
       }
@@ -56,10 +36,11 @@ class PBKDF2BE extends Base {
 
   /**
    * decrypt data, return string
+   *
    * @param password - password must be required for decrypt
    * @param data - data for decrypt
+   * @returns {Promise<string>}
    */
-
   decrypt(password: string, data: string): Promise<string> {
     if (password === '' && data === '') {
       throw new Error('password and data is required');
@@ -70,14 +51,7 @@ class PBKDF2BE extends Base {
 
     return new Promise(async (resolve, reject) => {
       try {
-        const passkey = await this.instanceHelper.passkey(password);
-        const aesKey = await this.instanceHelper.aesKey(passkey);
-        const dataBuffer = this.instanceCommon.base64ToBuffer(data);
-        const resultBuffer = await this.instanceHelper.aesDecrypt(
-          aesKey,
-          dataBuffer
-        );
-        resolve(this.instanceCommon.bufferToString(resultBuffer));
+        resolve(await this.instanceHelper.processToDencrypt(password, data));
       } catch (error: any) {
         reject(error.message);
       }