@irfanshadikrishad/cipher 1.0.4 → 1.0.5

package/README.md

@@ -2,12 +2,14 @@
 
 A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications.
 
+![NPM Version](https://img.shields.io/npm/v/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=81B29A)
+![NPM Downloads](https://img.shields.io/npm/dw/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=BE9A60)
+![NPM Unpacked Size](https://img.shields.io/npm/unpacked-size/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=655699)
+
 #### 🚀 Installation
 
 Install the package via npm:
 
-npm:
-
 ```bash
 npm install @irfanshadikrishad/cipher
 ```
@@ -41,14 +43,15 @@ 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 |
+| 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 |
 
 More ciphers coming soon...
 

package/dist/Cipher.d.ts

@@ -4,6 +4,7 @@ import { Playfair } from "./ciphers/Playfair.js";
 import { Vigenere } from "./ciphers/Vigenere.js";
 import { Alphabet } from "./ciphers/Alphabet.js";
 import { Salsa20 } from "./ciphers/Salsa20.js";
+import { ADFGVX } from "./ciphers/ADFGVX.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.
@@ -37,6 +38,12 @@ export declare abstract class Cipher {
      * @param counter 64-bit counter
      */
     static Salsa20: typeof Salsa20;
+    /**
+     * The ADFGVX cipher was a manually applied field cipher used by the Imperial German Army during World War I.
+     * @param key - more than 1 characters long (more length, more secure)
+     * @param codeword - 36 characters long
+     */
+    static ADFGVX: typeof ADFGVX;
     abstract encrypt(text: string): string | Uint8Array;
     abstract decrypt(text: string | Uint8Array): string;
 }

package/dist/ciphers/ADFGVX.d.ts

@@ -0,0 +1,13 @@
+import { Cipher } from "../Cipher.js";
+export declare class ADFGVX extends Cipher {
+    private key;
+    private codeword;
+    private polybiusSquare;
+    private reverseSquare;
+    private adfgvx;
+    constructor(key?: string | null, codeword?: string | null);
+    private createPolybiusSquare;
+    private columnarTranspose;
+    encrypt(text: string): string;
+    decrypt(text: string): string;
+}

package/dist/ciphers/ADFGVX.js

@@ -0,0 +1,89 @@
+import { Cipher } from "../Cipher.js";
+export class ADFGVX extends Cipher {
+    constructor(key, codeword) {
+        super();
+        this.key = "CIPHER";
+        this.codeword = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        this.polybiusSquare = new Map();
+        this.reverseSquare = new Map();
+        this.adfgvx = ["A", "D", "F", "G", "V", "X"];
+        if (key)
+            this.key = key.toUpperCase();
+        if (codeword)
+            this.codeword = codeword.toUpperCase();
+        this.createPolybiusSquare(this.codeword);
+    }
+    createPolybiusSquare(codeword) {
+        const uniqueLetters = [];
+        for (const char of codeword.toUpperCase()) {
+            if (!uniqueLetters.includes(char)) {
+                uniqueLetters.push(char);
+            }
+        }
+        const remainingChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+            .split("")
+            .filter((char) => !uniqueLetters.includes(char));
+        const alphabet = [...uniqueLetters, ...remainingChars];
+        let index = 0;
+        for (const row of this.adfgvx) {
+            for (const col of this.adfgvx) {
+                const letter = alphabet[index];
+                const code = row + col;
+                this.polybiusSquare.set(letter, code);
+                this.reverseSquare.set(code, letter);
+                index++;
+            }
+        }
+    }
+    columnarTranspose(text, decrypt = false) {
+        const keyOrder = [...this.key]
+            .map((char, index) => ({ char, index }))
+            .sort((a, b) => a.char.localeCompare(b.char))
+            .map((item) => item.index);
+        const numCols = this.key.length;
+        const numRows = Math.ceil(text.length / numCols);
+        const grid = Array.from({ length: numRows }, () => new Array(numCols).fill(""));
+        if (!decrypt) {
+            let charIndex = 0;
+            for (let row = 0; row < numRows; row++) {
+                for (let col = 0; col < numCols; col++) {
+                    if (charIndex < text.length) {
+                        grid[row][col] = text[charIndex++];
+                    }
+                }
+            }
+            return keyOrder
+                .map((col) => grid.map((row) => row[col]).join(""))
+                .join("");
+        }
+        else {
+            const sortedKeyOrder = [...keyOrder].sort((a, b) => this.key[a].localeCompare(this.key[b]));
+            let charIndex = 0;
+            for (const sortedCol of sortedKeyOrder) {
+                for (let row = 0; row < numRows; row++) {
+                    if (charIndex < text.length) {
+                        grid[row][sortedCol] = text[charIndex++];
+                    }
+                }
+            }
+            return grid.flat().join("");
+        }
+    }
+    encrypt(text) {
+        const plaintext = text.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+        const polybiusText = plaintext
+            .split("")
+            .map((char) => this.polybiusSquare.get(char) || "")
+            .join("");
+        return this.columnarTranspose(polybiusText);
+    }
+    decrypt(text) {
+        var _a;
+        const encrypted = text.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+        const intermediate = this.columnarTranspose(encrypted, true);
+        const polybiusText = ((_a = intermediate.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map((char) => {
+            return this.reverseSquare.get(char) || "";
+        })) || [];
+        return polybiusText.join("");
+    }
+}

package/dist/index.js

@@ -5,10 +5,12 @@ import { Playfair } from "./ciphers/Playfair.js";
 import { Vigenere } from "./ciphers/Vigenere.js";
 import { Alphabet } from "./ciphers/Alphabet.js";
 import { Salsa20 } from "./ciphers/Salsa20.js";
+import { ADFGVX } from "./ciphers/ADFGVX.js";
 Cipher.Caesar = Caesar;
 Cipher.Atbash = Atbash;
 Cipher.Playfair = Playfair;
 Cipher.Vigenere = Vigenere;
 Cipher.Alphabet = Alphabet;
 Cipher.Salsa20 = Salsa20;
+Cipher.ADFGVX = ADFGVX;
 export { Cipher };

package/package.json

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