spd-lib 1.0.7 → 1.0.9

package/index.js

@@ -24,22 +24,19 @@ class SPD {
 const userKey = pqcKey.publicKey;
 this.userKey = userKey;
 this.salt = salt;
-this.pwd = true;
     }
 
     async addData(name, data) {
-        if (!name || typeof name !== 'string' || !name.trim() || !data || typeof data !== 'string' || !data.trim()) {
-            throw new Error('Invalid name or data. Both must be non-empty strings.');
-        }
-
+        
 
+        const dmap = await this.CITS(data)
         await sodium.ready;
-        const dat = Buffer.from(data);
+        const dat = Buffer.from(dmap[0]);
         const compressedData = zlib.deflateSync(dat);
         const nonce = sodium.randombytes_buf(sodium.crypto_box_NONCEBYTES);
         const encryptedData = sodium.crypto_secretbox_easy(compressedData, nonce, this.userKey);
         const hash = crypto.createHash('sha256').update(encryptedData).digest('hex');
-        this.data.push({ dataName: name, nonce: Array.from(nonce), data: Array.from(encryptedData), hash });
+        this.data.push({ dataName: name, nonce: Array.from(nonce), data: Array.from(encryptedData), hash, dataType: dmap[1] });
     }
 
     saveToFile(outputPath) {
@@ -48,8 +45,7 @@ this.pwd = true;
         }
 
         const keyPair = {
-            publicKey: Array.from(this.keyPair.publicKey),
-            privateKey: Array.from(this.keyPair.privateKey)
+            publicKey: Array.from(this.keyPair.publicKey)
         };
         const spdData = JSON.stringify({ keyPair, data: this.data, salt: Array.from(this.salt) });
         const compressedSpdData = zlib.deflateSync(spdData);
@@ -72,14 +68,14 @@ this.pwd = true;
         const spd = new SPD();
         spd.userKey = pbk;
         spd.keyPair = {
-            publicKey: Buffer.from(keyPair.publicKey),
-            privateKey: Buffer.from(keyPair.privateKey)
+            publicKey: Buffer.from(keyPair.publicKey)
         };
         spd.data = data.map(dat => ({
             dataName: dat.dataName,
             nonce: Buffer.from(dat.nonce),
             data: Buffer.from(dat.data),
-            hash: dat.hash
+            hash: dat.hash,
+            dataType: dat.dataType
         }));
         spd.data.forEach(dat => {
             const calculatedHash = crypto.createHash('sha256').update(Buffer.from(dat.data)).digest('hex');
@@ -93,10 +89,11 @@ this.pwd = true;
     async extractData() {
         await sodium.ready;
         let extractedFiles = {};
-        this.data.forEach(dat => {
+        this.data.forEach(async dat => {
             const decryptedData = sodium.crypto_secretbox_open_easy(dat.data, dat.nonce, this.userKey);
             const decompressedData = zlib.inflateSync(decryptedData);
-            extractedFiles[dat.dataName] = decompressedData.toString('utf8');
+            const dt = decompressedData.toString('utf8');
+            extractedFiles[dat.dataName] = await this.CSTI(dt, dat.dataType);
         });
         return extractedFiles;
     }
@@ -119,6 +116,48 @@ this.pwd = true;
         });
     }
 
+    saveData() {
+        const keyPair = {
+            publicKey: Array.from(this.keyPair.publicKey)
+        };
+        const spdData = JSON.stringify({ keyPair, data: this.data, salt: Array.from(this.salt) });
+        const compressedSpdData = zlib.deflateSync(spdData);
+        return compressedSpdData;
+    }
+
+    async loadFromString(spdData, passcode) {
+        if (!spdData || typeof spdData !== 'string' || !spdData.trim() || !passcode || typeof passcode !== 'string' || !passcode.trim()) {
+            throw new Error('Invalid SPD path or passcode.');
+        }
+      
+        await sodium.ready;
+        const spdDataBuffer = Buffer.from(spdData, 'base64');
+        const spdData2 = zlib.inflateSync(spdDataBuffer).toString('utf8');
+        const { keyPair, data, salt } = JSON.parse(spdData2);
+      
+        const { pqcKey } = await new SPD().convertPasscodeToPQCKeySalted(passcode, new Uint8Array(salt));
+        const pbk = pqcKey.publicKey;
+        const spd = new SPD();
+        spd.userKey = pbk;
+        spd.keyPair = {
+            publicKey: Buffer.from(keyPair.publicKey)
+        };
+        spd.data = data.map(dat => ({
+            dataName: dat.dataName,
+            nonce: Buffer.from(dat.nonce),
+            data: Buffer.from(dat.data),
+            hash: dat.hash,
+            dataType: dat.dataType
+        }));
+        spd.data.forEach(dat => {
+            const calculatedHash = crypto.createHash('sha256').update(Buffer.from(dat.data)).digest('hex');
+            if (calculatedHash !== dat.hash) {
+                throw new Error(`Data integrity check failed for ${dat.dataName}`);
+            }
+        });
+        return spd;
+      }
+
     async convertPasscodeToPQCKeySalted(passcode, salt) {
         if (!passcode || typeof passcode !== 'string' || !passcode.trim() || passcode.length < 8 || !salt || !(salt instanceof Uint8Array) || salt.length !== 16) {
             throw new Error('Invalid passcode or salt.');
@@ -127,7 +166,7 @@ this.pwd = true;
         const { pbk } = await SPD.derivePBK(passcode, salt);
         await sodium.ready;
         const keyPair = sodium.crypto_kx_seed_keypair(pbk.slice(0, sodium.crypto_kx_SEEDBYTES));
-        return { pqcKey: { publicKey: keyPair.publicKey, privateKey: keyPair.privateKey }, salt };
+        return { pqcKey: { publicKey: keyPair.publicKey }, salt };
     }
 
     async convertPasscodeToPQCKey(passcode) {
@@ -138,10 +177,125 @@ this.pwd = true;
         const { pbk, salt } = await SPD.derivePBK(passcode, crypto.getRandomValues(new Uint8Array(16)));
         await sodium.ready;
         const keyPair = sodium.crypto_kx_seed_keypair(pbk.slice(0, sodium.crypto_kx_SEEDBYTES));
-        return { pqcKey: { publicKey: keyPair.publicKey, privateKey: keyPair.privateKey }, salt };
+        return { pqcKey: { publicKey: keyPair.publicKey }, salt };
     }
-}
+    async TDT(data) {
+        const classTypeMap = {
+            '[object Array]': 'Array',
+            '[object Uint8Array]': 'Uint8Array',
+            '[object Uint16Array]': 'Uint16Array',
+            '[object Uint32Array]': 'Uint32Array',
+            '[object BigInt64Array]': 'BigInt64Array',
+            '[object BigUint64Array]': 'BigUint64Array',
+            '[object Float32Array]': 'Float32Array',
+            '[object Float64Array]': 'Float64Array',
+            '[object Map]': 'Map',
+            '[object Set]': 'Set',
+            '[object Date]': 'Date',
+            '[object RegExp]': 'RegExp',
+            '[object Error]': 'Error'
+        };
+        
+        const objectType = Object.prototype.toString.call(data);
+        const mappedType = classTypeMap[objectType];
+        return mappedType;
+    }
+    async isNumArr(dataType) {
+        if(dataType === 'Uint8Array' || dataType === 'Uint16Array' || dataType === 'Uint32Array' || dataType === 'BigInt64Array' || dataType === 'BigUint64Array' || dataType === 'Float32Array' || dataType === 'Float64Array'){
+            return true;
+        }
+    }
+    async isSWM(dataType) {
+        if(dataType === 'Map' || dataType === 'Set' || dataType === 'WeakMap' || dataType === 'WeakSet'){
+            return true;
+        }
+    }
+    async isDRE(dataType) {
+        if(dataType === 'Date' || dataType === 'RegExp' || dataType === 'Error'){
+            return true;
+        }
+    }
+    async CITS(data) {
+        const dataType = typeof data;
+        if (dataType === 'string' || dataType === 'number' || dataType === 'boolean') {
+            return [data.toString(), dataType];
+        }
+        if(typeof data === 'object'){
+            const type = await this.TDT(data)
+            if(type === 'Array'){
+                return [JSON.stringify(data),'Array'];
+            }
+            if(await this.isNumArr(type)){
+                return [JSON.stringify(Array.from(data)),type];
+            }
+            if(await this.isSWM(type)){
+    
+                return [JSON.stringify([...data]),type];
+            }
+            if(await this.isDRE(type)){
+                return [data.toString(),type];
+            }
+            return [JSON.stringify(data), typeof data];
+        }
+    }
+    async CSTI(data,type) {
+        if(type === 'string') {
+            return data
+        }
+        if(type === 'number'){
+            return parseFloat(data);
+        }
+        if(type === 'boolean'){
+            return (data === 'true')&&(data !== 'false');
+        }
+        if(type === 'object' || type === 'Array'){
+            return JSON.parse(data);
+        }
+        if(type === 'Uint8Array'){
+            return new Uint8Array(JSON.parse(data));
+        }
+        if(type === 'Uint16Array'){
+            return new Uint16Array(JSON.parse(data));
+        }
+        if(type === 'Uint32Array'){
 
+            return new Uint32Array(JSON.parse(data));
+        }
+        if(type === 'BigInt64Array'){
+            return new BigInt64Array(JSON.parse(data));
+        }
+        if(type === 'BigUint64Array'){
+            return new BigUint64Array(JSON.parse(data));
+        }
+        if(type === 'Float32Array'){
+            return new Float32Array(JSON.parse(data));
+        }
+        if(type === 'Float64Array'){
+            return new Float64Array(JSON.parse(data));
+        }
+        if(type === 'Map'){
+            return new Map(JSON.parse(data));
+        }
+        if(type === 'Set'){
+            return new Set(JSON.parse(data));
+        }
+        if(type === 'WeakMap'){
+            return new WeakMap(JSON.parse(data));
+        }
+        if(type === 'WeakSet'){
+            return new WeakSet(JSON.parse(data));
+        }
+        if(type === 'Date'){
+            return new Date(data);
+        }
+        if(type === 'RegExp'){
+            return new RegExp(data);
+        }
+        if(type === 'Error'){
+            return new Error(data);
+        }
+    }
+}
 
 module.exports = {
     SPD,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spd-lib",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "SPD or Secure Packaged Data is a compress PQC protected file format to store sensitive data localy",
   "main": "index.js",
   "scripts": {

package/readme.md

@@ -1,44 +1,137 @@
-```markdown
 # Secure Packaged Data (SPD)
 
-Secure Packaged Data (SPD) is a Node.js package for securely storing and retrieving sensitive data persistently. It utilizes encryption, hashing, and compression techniques to ensure the confidentiality, integrity, and efficiency of data storage.
+The Secure Packaged Data (SPD) module provides functionality to securely store and retrieve data using encryption, compression, and hashing. This README explains how to use the SPD class and its methods.
 
 ## Installation
 
-You can install SPD via npm:
+First, ensure you have Node.js installed. Then, install the required packages:
 
-```bash
+```sh
 npm install spd-lib
 ```
 
 ## Usage
 
+Below are the primary functionalities of the SPD class.
+
+### Initialization
+
+Create an instance of the SPD class:
+
 ```javascript
 const { SPD } = require('spd-lib');
 
-// Example usage
+const spd = new SPD();
+```
+
+### Setting Passcode
+
+Set a passcode for encrypting the data:
+
+```javascript
+await spd.setPassKey('your-passcode');
+```
+
+### Adding Data
+
+Add data to the SPD instance:
+
+```javascript
+await spd.addData('dataName', yourData);
+```
+
+### Saving Data to File
+
+Save the encrypted and compressed data to a file:
+
+```javascript
+spd.saveToFile('path/to/output.spd');
+```
+
+### Loading Data from File
+
+Load the data from an SPD file:
+
+```javascript
+const loadedSPD = await SPD.loadFromFile('path/to/output.spd', 'your-passcode');
+```
+
+### Extracting Data
+
+Extract and decrypt the data from the SPD instance:
+
+```javascript
+const extractedData = await loadedSPD.extractData();
+console.log(extractedData);
+```
+
+## Example
+
+Here is a complete example of how to use the SPD module:
+
+```javascript
+const { SPD } = require('./path/to/spd.js');
+
 (async () => {
+    const spd = new SPD();
+    await spd.setPassKey('your-passcode');
 
-    const passcode = 'your-secure-passcode';
-    const spd = new SPD(); // Create a new SPD object // Set the passcode to the SPD object
-    await spd.setPassKey(passcode); // Set Passkey
-    await spd.addData('settings', '{"theme":"dark"}'); // Add a data to the SPD object
-    await spd.addData('tabs', '[{"title":"Home","url":"https://example.com"},{"title":"About","url":"https://example.com/about"}]'); // Add more data to the SPD object
-    spd.saveToFile('output.spd'); // Save SPD file to disk with the salt
-    const loadedSpd = await SPD.loadFromFile('output.spd', passcode); // Load SPD file with the passcode
-    const extractedData = await loadedSpd.extractData(); // Extract data to memory
-    console.log(extractedData); // Print extracted files to console
+    const myData = {
+        name: "Alice",
+        age: 30,
+        isMember: true,
+        preferences: ["reading", "gaming"]
+    };
+
+    await spd.addData('userData', myData);
+
+    spd.saveToFile('path/to/output.spd');
+
+    const loadedSPD = await SPD.loadFromFile('path/to/output.spd', 'your-passcode');
+    const extractedData = await loadedSPD.extractData();
+
+    console.log(extractedData);
 })();
 ```
 
-## Features
+## Methods
+
+### `async setPassKey(passcode)`
+
+Sets the passcode for encrypting and decrypting data.
+
+- **Parameters**: `passcode` (string) - The passcode to be used.
+
+### `async addData(name, data)`
+
+Adds data to the SPD instance.
+
+- **Parameters**:
+  - `name` (string) - The name of the data.
+  - `data` (any) - The data to be stored.
+
+### `saveToFile(outputPath)`
+
+Saves the encrypted and compressed data to a file.
+
+- **Parameters**: `outputPath` (string) - The path to save the file.
+
+### `static async loadFromFile(spdPath, passcode)`
+
+Loads the SPD data from a file.
+
+- **Parameters**:
+  - `spdPath` (string) - The path to the SPD file.
+  - `passcode` (string) - The passcode to decrypt the data.
+
+- **Returns**: An instance of SPD with the loaded data.
+
+### `async extractData()`
+
+Extracts and decrypts the data from the SPD instance.
 
-- **Encryption**: Data is encrypted using a symmetric key derived from a user-provided passcode.
-- **Compression**: Data is compressed before encryption to reduce storage size.
-- **Data Integrity**: Hashing techniques ensure the integrity of stored data.
-- **Asynchronous Operations**: Utilizes asynchronous programming for file I/O and cryptographic operations.
+- **Returns**: An object with the decrypted data.
 
 ## License
 
-This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
-```
+This project is licensed under the MIT License.