k9crypt 1.0.5

package/README.md

@@ -0,0 +1,36 @@
+# K9Crypt Encryption Algorithm
+
+This is a special encryption algorithm created for K9Crypt.
+
+## Installation
+
+```bash
+npm install k9crypt
+```
+
+## Usage
+
+```javascript
+const k9crypt = require('k9crypt');
+
+async function test() {
+    const secretKey = 'VeryLongSecretKey!@#1234567890';
+    const encryptor = new k9crypt(secretKey);
+    const plaintext = 'Hello, World!';
+
+    try {
+        const encrypted = await encryptor.encrypt(plaintext);
+        console.log('Encrypted data:', encrypted);
+
+        const decrypted = await encryptor.decrypt(encrypted);
+        console.log('Decrypted data:', decrypted);
+    } catch (error) {
+        console.error('Encryption error:', error);
+    }
+}
+
+test();
+```
+
+## License
+This project is licensed under the MIT license.

package/index.js

@@ -0,0 +1,3 @@
+const k9crypt = require('./src/index');
+
+module.exports = k9crypt;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "k9crypt",
+  "version": "1.0.5",
+  "description": "A special encryption algorithm created for K9Crypt.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "secure",
+    "encryption",
+    "k9crypt",
+    "crypto",
+    "crypto-js",
+    "bcrypt",
+    "decrypt"
+  ],
+  "author": "K9Crypt Team",
+  "license": "MIT",
+  "dependencies": {
+    "bcrypt": "^5.1.1",
+    "crypto-js": "^4.2.0",
+    "lz4": "^0.6.5",
+    "node-forge": "^1.3.1",
+    "xxhash": "^0.3.0"
+  },
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/K9Crypt/module.git"
+  },
+  "bugs": {
+    "url": "https://github.com/K9Crypt/module/issues"
+  },
+  "homepage": "https://k9crypt.xyz"
+}

package/src/constants.js

@@ -0,0 +1,10 @@
+module.exports = {
+    SALT_SIZE: 32,
+    IV_SIZE: 16,
+    KEY_SIZE: 32,
+    TAG_SIZE: 16,
+    PBKDF2_ITERATIONS: 310000,
+    HASH_SEED: 0xCAFEBABE,
+    PEPPER: 'veryLongAndComplexPepperValue123!@#$%^&*()_+[]{}|;:,.<>?',
+    HMAC_KEY: 'veryLongAndComplexHMACKeyValue456!@#$%^&*()_+[]{}|;:,.<>?',
+};

package/src/index.js

@@ -0,0 +1,54 @@
+const crypto = require('crypto');
+const { compress, decompress } = require('./utils/compression');
+const { deriveKey } = require('./utils/keyDerivation');
+const { encrypt, decrypt } = require('./utils/encryption');
+const { hash, verifyHash } = require('./utils/hashing');
+const { SALT_SIZE, IV_SIZE, TAG_SIZE } = require('./constants');
+
+class K9crypt {
+    constructor(secretKey) {
+        this.secretKey = secretKey;
+    }
+
+    async encrypt(plaintext) {
+        try {
+            const compressed = await compress(plaintext);
+            const salt = crypto.randomBytes(SALT_SIZE);
+            const key = await deriveKey(this.secretKey, salt);
+            const { iv, encrypted, tag } = encrypt(compressed, key);
+            const dataToHash = Buffer.concat([salt, iv, encrypted, tag]);
+            const dataHash = hash(dataToHash);
+            const result = Buffer.concat([salt, iv, encrypted, tag, dataHash]);
+            return result.toString('base64');
+        } catch (error) {
+            console.error('Encryption error:', error);
+            throw new Error('Encryption failed');
+        }
+    }
+
+    async decrypt(ciphertext) {
+        try {
+            const data = Buffer.from(ciphertext, 'base64');
+            const salt = data.slice(0, SALT_SIZE);
+            const iv = data.slice(SALT_SIZE, SALT_SIZE + IV_SIZE);
+            const encrypted = data.slice(SALT_SIZE + IV_SIZE, -TAG_SIZE - 64);
+            const tag = data.slice(-TAG_SIZE - 64, -64);
+            const dataHash = data.slice(-64);
+
+            const dataToVerify = data.slice(0, -64);
+            if (!verifyHash(dataToVerify, dataHash)) {
+                throw new Error('Data integrity check failed');
+            }
+
+            const key = await deriveKey(this.secretKey, salt);
+            const decrypted = decrypt(encrypted, key, iv, tag);
+            const decompressed = await decompress(decrypted);
+            return decompressed.toString('utf8');
+        } catch (error) {
+            console.error('Decryption error:', error);
+            throw new Error('Decryption failed');
+        }
+    }
+}
+
+module.exports = K9crypt;

package/src/utils/compression.js

@@ -0,0 +1,19 @@
+const zlib = require('zlib');
+
+exports.compress = (data) => {
+    return new Promise((resolve, reject) => {
+        zlib.brotliCompress(Buffer.from(data, 'utf8'), (err, compressed) => {
+            if (err) reject(err);
+            else resolve(compressed);
+        });
+    });
+};
+
+exports.decompress = (data) => {
+    return new Promise((resolve, reject) => {
+        zlib.brotliDecompress(data, (err, decompressed) => {
+            if (err) reject(err);
+            else resolve(decompressed);
+        });
+    });
+};

package/src/utils/encryption.js

@@ -0,0 +1,19 @@
+const crypto = require('crypto');
+const { IV_SIZE } = require('../constants');
+
+exports.encrypt = (data, key) => {
+    const iv = crypto.randomBytes(IV_SIZE);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    let encrypted = cipher.update(data);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return { iv, encrypted, tag };
+};
+
+exports.decrypt = (encrypted, key, iv, tag) => {
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    let decrypted = decipher.update(encrypted);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted;
+};

package/src/utils/hashing.js

@@ -0,0 +1,10 @@
+const crypto = require('crypto');
+const { HASH_SEED, HMAC_KEY } = require('../constants');
+
+exports.hash = (data) => {
+    const hmac = crypto.createHmac('sha512', HMAC_KEY);
+    hmac.update(data);
+    return hmac.digest();
+};
+
+exports.verifyHash = (data, hash) => crypto.timingSafeEqual(exports.hash(data), hash);

package/src/utils/keyDerivation.js

@@ -0,0 +1,12 @@
+const crypto = require('crypto');
+const { PBKDF2_ITERATIONS, KEY_SIZE, PEPPER } = require('../constants');
+
+exports.deriveKey = (password, salt) => {
+    return new Promise((resolve, reject) => {
+        const pepperedPassword = password + PEPPER;
+        crypto.pbkdf2(pepperedPassword, salt, PBKDF2_ITERATIONS, KEY_SIZE, 'sha512', (err, key) => {
+            if (err) reject(err);
+            resolve(key);
+        });
+    });
+};