ayiin 2.0.50 → 2.0.51

package/dist/methods/crypt.d.ts

@@ -1,25 +1,11 @@
 declare class Crypt {
-    /**
-     * Performs Base encryption and decryption.
-     * @param {string | Buffer} input - The input data to be encrypted or decrypted.
-     * @param {string} key - The encryption/decryption key.
-     * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
-     */
+    private chars;
+    private base62Encode;
+    private base62Decode;
+    private generateKeystream;
     private baseCrypt;
-    /**
-     * Encrypts a plaintext message using the given key.
-     * @param {string} text - The plaintext message to be encrypted.
-     * @param {string} key - The encryption key.
-     * @returns {string} - The encrypted data in Hex format.
-     */
-    encrypt: (text: string, key: string, bufferEncoding?: BufferEncoding) => string;
-    /**
-     * Decrypts an encrypted message using the given key.
-     * @param {string} encrypted - The encrypted data in Hex format.
-     * @param {string} key - The decryption key.
-     * @returns {string} - The decrypted plaintext message.
-     */
-    decrypt: (encrypted: string, key: string, bufferEncoding?: BufferEncoding) => string;
+    encrypt: (text: string, key: string) => string;
+    decrypt: (token: string, key: string) => string | null;
     /**
      * Converts a Hex string to its corresponding ASCII representation.
      * @param {string} hexString - The Hex string to be converted.

package/dist/methods/crypt.js

@@ -5,41 +5,87 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = __importDefault(require("crypto"));
 class Crypt {
-    /**
-     * Performs Base encryption and decryption.
-     * @param {string | Buffer} input - The input data to be encrypted or decrypted.
-     * @param {string} key - The encryption/decryption key.
-     * @returns {Buffer} - The encrypted or decrypted data as a Buffer.
-     */
-    baseCrypt = (input, key) => {
-        const inputBuffer = Buffer.from(input, "ascii");
-        const keyBuffer = Buffer.from(key, "ascii");
-        const resultBuffer = Buffer.alloc(inputBuffer.length);
-        for (let i = 0; i < inputBuffer.length; i++) {
-            resultBuffer[i] = inputBuffer[i] ^ keyBuffer[i % keyBuffer.length];
+    chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    // Base62 encode: buffer → base62 string
+    base62Encode(buffer) {
+        let digits = [0];
+        for (const byte of buffer) {
+            let carry = byte;
+            for (let j = 0; j < digits.length; j++) {
+                const val = digits[j] * 256 + carry;
+                digits[j] = val % 62;
+                carry = Math.floor(val / 62);
+            }
+            while (carry > 0) {
+                digits.push(carry % 62);
+                carry = Math.floor(carry / 62);
+            }
         }
-        return resultBuffer;
-    };
-    /**
-     * Encrypts a plaintext message using the given key.
-     * @param {string} text - The plaintext message to be encrypted.
-     * @param {string} key - The encryption key.
-     * @returns {string} - The encrypted data in Hex format.
-     */
-    encrypt = (text, key, bufferEncoding = "base64") => {
-        const encryptedBuffer = this.baseCrypt(text, key);
-        return encryptedBuffer.toString(bufferEncoding);
+        return (digits
+            .reverse()
+            .map((d) => this.chars[d])
+            .join("") || "0");
+    }
+    // Base62 decode: string → buffer
+    base62Decode(str) {
+        let digits = [0];
+        for (const c of str) {
+            let carry = this.chars.indexOf(c);
+            for (let j = 0; j < digits.length; j++) {
+                const val = digits[j] * 62 + carry;
+                digits[j] = val & 0xff;
+                carry = val >> 8;
+            }
+            while (carry > 0) {
+                digits.push(carry & 0xff);
+                carry >>= 8;
+            }
+        }
+        return Buffer.from(digits.reverse());
+    }
+    generateKeystream(key, length) {
+        const result = Buffer.alloc(length);
+        let pos = 0;
+        let counter = 0;
+        while (pos < length) {
+            const hash = crypto_1.default.createHash("sha256");
+            hash.update(key);
+            hash.update(Buffer.from(counter.toString()));
+            const digest = hash.digest();
+            const copy = Math.min(length - pos, digest.length);
+            digest.copy(result, pos, 0, copy);
+            pos += copy;
+            counter++;
+        }
+        return result;
+    }
+    baseCrypt(input, key) {
+        const keystream = this.generateKeystream(key, input.length);
+        const output = Buffer.alloc(input.length);
+        for (let i = 0; i < input.length; i++) {
+            output[i] = input[i] ^ keystream[i];
+        }
+        return output;
+    }
+    encrypt = (text, key) => {
+        const input = Buffer.from(text, "utf8");
+        const encrypted = this.baseCrypt(input, key);
+        const cipher = this.base62Encode(encrypted);
+        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
+        const signature = this.base62Encode(hmac);
+        return `${cipher}.${signature}`;
     };
-    /**
-     * Decrypts an encrypted message using the given key.
-     * @param {string} encrypted - The encrypted data in Hex format.
-     * @param {string} key - The decryption key.
-     * @returns {string} - The decrypted plaintext message.
-     */
-    decrypt = (encrypted, key, bufferEncoding = "base64") => {
-        const encryptedBuffer = Buffer.from(encrypted, bufferEncoding);
-        const decryptedBuffer = this.baseCrypt(encryptedBuffer, key);
-        return decryptedBuffer.toString("ascii");
+    decrypt = (token, key) => {
+        const [cipher, signature] = token.split(".");
+        if (!cipher || !signature)
+            return null;
+        const hmac = crypto_1.default.createHmac("sha256", key).update(cipher).digest();
+        const expected = this.base62Encode(hmac);
+        if (expected !== signature)
+            return null;
+        const input = this.base62Decode(cipher);
+        const decrypted = this.baseCrypt(input, key);
+        return decrypted.toString("utf8");
     };
     /**
      * Converts a Hex string to its corresponding ASCII representation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ayiin",
-  "version": "2.0.50",
+  "version": "2.0.51",
   "author": {
     "name": "AyiinXd",
     "url": "https://github.com/AyiinXd"