@irfanshadikrishad/cipher 1.0.5 → 1.0.7

package/README.md

@@ -43,15 +43,17 @@ console.log(caesar.encrypt("hello world")) // Output: "nkrru cuxrj"
 
 This library provides implementations of various classical and modern ciphers:
 
-| Cipher                                              | Type                                     | Key required? | Strength | Used In/Notes                              |
-| --------------------------------------------------- | ---------------------------------------- | ------------- | -------- | ------------------------------------------ |
-| [Caesar Cipher](/docs/en/ciphers/CAESAR.md)         | Substitution                             | No            | Low      | Ancient Rome, Simple Obsfuscation          |
-| [Atbash Cipher](/docs/en/ciphers/ATBASH.md)         | Substitution                             | No            | Low      | Hebrew Cipher, Basic Encryption            |
-| [Playfair Cipher](/docs/en/ciphers/PLAYFAIR.md)     | Diagraph-based                           | Yes           | Medium   | Used in WWI & WWII                         |
-| [Vigenère Cipher](/docs/en/ciphers/VIGENERE.md)     | Polyalphabetic                           | Yes           | Medium   | Used in Historical Documents               |
-| [The Alphabet Cipher](/docs/en/ciphers/ALPHABET.md) | Polyalphabetic                           | Yes           | Medium   | Inspired by Vigenere, Cryptography Puzzles |
-| [Salsa20](/docs/en/ciphers/SALSA20.md)              | Stream Cipher                            | Yes           | High     | Modern Cryptography, Secure Communications |
-| [ADFGVX](/docs/en/ciphers/ADFGVX.md)                | Polybius Square + Columnar Transposition | Yes           | Medium   | Used in WWI, Known for 6x6 polybius square |
+| Cipher                                              | Type                                     | Key required? | Strength | Used In/Notes                                       |
+| --------------------------------------------------- | ---------------------------------------- | ------------- | -------- | --------------------------------------------------- |
+| [Caesar Cipher](/docs/en/ciphers/CAESAR.md)         | Substitution                             | No            | Low      | Ancient Rome, Simple Obsfuscation                   |
+| [Atbash Cipher](/docs/en/ciphers/ATBASH.md)         | Substitution                             | No            | Low      | Hebrew Cipher, Basic Encryption                     |
+| [Playfair Cipher](/docs/en/ciphers/PLAYFAIR.md)     | Diagraph-based                           | Yes           | Medium   | Used in WWI & WWII                                  |
+| [Vigenère Cipher](/docs/en/ciphers/VIGENERE.md)     | Polyalphabetic                           | Yes           | Medium   | Used in Historical Documents                        |
+| [The Alphabet Cipher](/docs/en/ciphers/ALPHABET.md) | Polyalphabetic                           | Yes           | Medium   | Inspired by Vigenere, Cryptography Puzzles          |
+| [Salsa20](/docs/en/ciphers/SALSA20.md)              | Stream Cipher                            | Yes           | High     | Modern Cryptography, Secure Communications          |
+| [ADFGVX](/docs/en/ciphers/ADFGVX.md)                | Polybius Square + Columnar Transposition | Yes           | Medium   | Used in WWI, Known for 6x6 polybius square          |
+| [AES](/docs/en/ciphers/AES.md)                      | Symmetric Block Cipher                   | Yes           | High     | Also known as, Rijndael                             |
+| [DES](/docs/en/ciphers/DES.md)                      | Symmetric Block Cipher                   | Yes           | Medium   | 56-bit key, Used in legacy systems, replaced by AES |
 
 More ciphers coming soon...
 

package/dist/Cipher.d.ts

@@ -5,6 +5,8 @@ import { Vigenere } from "./ciphers/Vigenere.js";
 import { Alphabet } from "./ciphers/Alphabet.js";
 import { Salsa20 } from "./ciphers/Salsa20.js";
 import { ADFGVX } from "./ciphers/ADFGVX.js";
+import { AES } from "./ciphers/AES.js";
+import { DES } from "./ciphers/DES.js";
 export declare abstract class Cipher {
     /**
      * Caesar cipher is a substitution cipher where each letter in the plaintext is shifted a certain number of places down the alphabet.
@@ -44,6 +46,18 @@ export declare abstract class Cipher {
      * @param codeword - 36 characters long
      */
     static ADFGVX: typeof ADFGVX;
-    abstract encrypt(text: string): string | Uint8Array;
-    abstract decrypt(text: string | Uint8Array): string;
+    /**
+     * Advanced Encryption Standard (AES) is a symmetric encryption algorithm.
+     * @param key 256-bit (32 byte) key
+     * @param iv 128-bit (16 byte) initialization vector
+     */
+    static AES: typeof AES;
+    /**
+     * Data Encryption Standard (DES) is a symmetric encryption algorithm.
+     * @param key 8 characters long
+     * @param iv 8 characters long
+     */
+    static DES: typeof DES;
+    abstract encrypt(text: string): string;
+    abstract decrypt(text: string): string;
 }

package/dist/ciphers/AES.d.ts

@@ -0,0 +1,8 @@
+import { Cipher } from "../Cipher.js";
+export declare class AES extends Cipher {
+    private key;
+    private iv;
+    constructor(key: string, iv: string);
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+}

package/dist/ciphers/AES.js

@@ -0,0 +1,28 @@
+import crypto from "crypto";
+import { Cipher } from "../Cipher.js";
+import { Buffer } from "buffer";
+export class AES extends Cipher {
+    constructor(key, iv) {
+        super();
+        this.key = Buffer.from(key, "hex");
+        this.iv = Buffer.from(iv, "hex");
+        if (this.key.length !== 32) {
+            throw new Error("Invalid key length: AES-256 requires a 32-byte key");
+        }
+        if (this.iv.length !== 16) {
+            throw new Error("Invalid IV length: AES requires a 16-byte IV");
+        }
+    }
+    encrypt(plaintext) {
+        const cipher = crypto.createCipheriv("aes-256-cbc", this.key, this.iv);
+        let encrypted = cipher.update(plaintext, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        return encrypted;
+    }
+    decrypt(ciphertext) {
+        const decipher = crypto.createDecipheriv("aes-256-cbc", this.key, this.iv);
+        let decrypted = decipher.update(ciphertext, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+}

package/dist/ciphers/DES.d.ts

@@ -0,0 +1,15 @@
+import { Cipher } from "../Cipher.js";
+export declare class DES extends Cipher {
+    private key;
+    constructor(key: string);
+    encrypt(text: string): string;
+    decrypt(text: string): string;
+    private pad;
+    private unpad;
+    private feistel;
+    private getRoundKey;
+    private f;
+    private permute;
+    private stringToBigInt;
+    private bigIntToString;
+}

package/dist/ciphers/DES.js

@@ -0,0 +1,87 @@
+import { Cipher } from "../Cipher.js";
+import { Buffer } from "buffer";
+const IP = [
+    // Initial Permutation
+    58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38,
+    30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1,
+    59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39,
+    31, 23, 15, 7,
+];
+const FP = [
+    // Final Permutation
+    40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14,
+    54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28,
+    35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9,
+    49, 17, 57, 25,
+];
+export class DES extends Cipher {
+    constructor(key) {
+        super();
+        if (key.length !== 8)
+            throw new Error("DES key must be exactly 8 characters.");
+        this.key = this.stringToBigInt(key);
+    }
+    encrypt(text) {
+        const paddedText = this.pad(text);
+        const encryptedBlocks = [];
+        for (let i = 0; i < paddedText.length; i += 8) {
+            const block = paddedText.substring(i, i + 8);
+            const input = this.stringToBigInt(block);
+            const permuted = this.permute(input, IP);
+            const encrypted = this.feistel(permuted);
+            const finalPerm = this.permute(encrypted, FP);
+            encryptedBlocks.push(finalPerm.toString(16).padStart(16, "0"));
+        }
+        return encryptedBlocks.join(""); // Concatenate hex strings
+    }
+    decrypt(text) {
+        let decryptedText = "";
+        for (let i = 0; i < text.length; i += 16) {
+            // 16 hex chars = 8 bytes
+            const block = BigInt("0x" + text.substring(i, i + 16));
+            const permuted = this.permute(block, IP);
+            const decrypted = this.feistel(permuted);
+            const finalPerm = this.permute(decrypted, FP);
+            decryptedText += this.bigIntToString(finalPerm);
+        }
+        return this.unpad(decryptedText);
+    }
+    pad(text) {
+        const padLength = 8 - (text.length % 8);
+        return text + String.fromCharCode(padLength).repeat(padLength);
+    }
+    unpad(text) {
+        const padLength = text.charCodeAt(text.length - 1);
+        return text.slice(0, -padLength);
+    }
+    feistel(input) {
+        let L = input >> BigInt(32);
+        let R = input & BigInt(0xffffffff);
+        for (let i = 0; i < 16; i++) {
+            const roundKey = this.getRoundKey();
+            const newR = L ^ this.f(R, roundKey);
+            L = R;
+            R = newR;
+        }
+        return (R << BigInt(32)) | L;
+    }
+    getRoundKey() {
+        return this.key; // Placeholder (Key Schedule logic needed)
+    }
+    f(block, roundKey) {
+        return block ^ roundKey; // Placeholder (Expand, S-Box, Permutation)
+    }
+    permute(input, table) {
+        let output = BigInt(0);
+        for (let i = 0; i < table.length; i++) {
+            output |= ((input >> BigInt(64 - table[i])) & BigInt(1)) << BigInt(63 - i);
+        }
+        return output;
+    }
+    stringToBigInt(str) {
+        return BigInt("0x" + Buffer.from(str, "utf8").toString("hex"));
+    }
+    bigIntToString(num) {
+        return Buffer.from(num.toString(16).padStart(16, "0"), "hex").toString("utf8");
+    }
+}

package/dist/index.js

@@ -6,6 +6,8 @@ import { Vigenere } from "./ciphers/Vigenere.js";
 import { Alphabet } from "./ciphers/Alphabet.js";
 import { Salsa20 } from "./ciphers/Salsa20.js";
 import { ADFGVX } from "./ciphers/ADFGVX.js";
+import { AES } from "./ciphers/AES.js";
+import { DES } from "./ciphers/DES.js";
 Cipher.Caesar = Caesar;
 Cipher.Atbash = Atbash;
 Cipher.Playfair = Playfair;
@@ -13,4 +15,6 @@ Cipher.Vigenere = Vigenere;
 Cipher.Alphabet = Alphabet;
 Cipher.Salsa20 = Salsa20;
 Cipher.ADFGVX = ADFGVX;
+Cipher.AES = AES;
+Cipher.DES = DES;
 export { Cipher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irfanshadikrishad/cipher",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications.",
   "homepage": "https://github.com/irfanshadikrishad/cipher#readme",
   "bugs": {