@irfanshadikrishad/cipher 1.0.3 → 1.0.5

package/README.md

@@ -2,29 +2,65 @@
 
 A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications.
 
-#### Installation
+![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:
 
 ```bash
-npm i @irfanshadikrishad/cipher
+npm install @irfanshadikrishad/cipher
 ```
 
-#### Usage
+yarn:
+
+```bash
+yarn add @irfanshadikrishad/cipher
+```
+
+bun:
+
+```bash
+bun add @irfanshadikrishad/cipher
+```
 
-```js
+#### 📖 Usage
+
+Import the library and use a cipher algorithm:
+
+```ts
 import { Cipher } from "@irfanshadikrishad/cipher"
 
-const ceaser = new Cipher.Ceaser(6)
+// Create a Caesar Cipher instance with a shift of 6
+const caesar = new Cipher.Caesar(6)
 
-console.log(ceaser.encrypt("hello world"))
+console.log(caesar.encrypt("hello world")) // Output: "nkrru cuxrj"
 ```
 
-#### Available Ciphers
+#### 🔐 Supported Ciphers
+
+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 |
+
+More ciphers coming soon...
+
+#### 🍀 Contribution
+
+To contribute on the codebase, follow [contribution guideline](/docs/en/CONTRIBUTING.md).
+
+#### ❤️ Support
 
-- Ceaser Cipher
-- Atbash Cipher
-- Playfair Cipher
-- Vigenere Cipher
-- The Alphabet Cipher
-- & more coming soon ...
+If you find this library useful, consider giving it a ⭐ on GitHub!
 
-#### Thanks for visiting (>'-'<)
+Thanks for visiting! (>'-'<)

package/dist/Cipher.d.ts

@@ -3,12 +3,47 @@ import { Atbash } from "./ciphers/Atbash.js";
 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.
+     * @param shift Number of places to shift the alphabet
+     */
     static Caesar: typeof Caesar;
+    /**
+     * Atbash cipher is a substitution cipher where the alphabet is reversed.
+     * A -> Z, B -> Y, C -> X, ..., Z -> A
+     */
     static Atbash: typeof Atbash;
+    /**
+     * Playfair cipher is a digraph substitution cipher that encrypts pairs of letters.
+     * @param key 5x5 grid of letters
+     */
     static Playfair: typeof Playfair;
+    /**
+     * Vigenère cipher is a polyalphabetic substitution cipher that encrypts the plaintext with a keyword.
+     * @param key Keyword to encrypt the plaintext
+     */
     static Vigenere: typeof Vigenere;
+    /**
+     * "The Alphabet Cipher" was a brief study published by Lewis Carroll in 1868, describing how to use the alphabet to send encrypted codes.
+     */
     static Alphabet: typeof Alphabet;
-    abstract encrypt(text: string): string;
-    abstract decrypt(text: string): string;
+    /**
+     * Salsa20 is a stream cipher developed by Daniel J. Bernstein.
+     * It is widely used in the industry and is considered secure.
+     * @param key 256-bit key
+     * @param nonce 64-bit nonce
+     * @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/ciphers/Salsa20.d.ts

@@ -0,0 +1,16 @@
+import { Cipher } from "../Cipher.js";
+export declare class Salsa20 extends Cipher {
+    private key;
+    private nonce;
+    private counter;
+    constructor(key: Uint8Array | string, nonce: Uint8Array | string, counter?: number);
+    private static rotateLeft;
+    private static quarterRound;
+    private generateKeystreamBlock;
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+    static generateKey(): string;
+    static generateNonce(): string;
+    static encodeBase64(uint8array: Uint8Array): string;
+    static decodeBase64(base64: string): Uint8Array;
+}

package/dist/ciphers/Salsa20.js

@@ -0,0 +1,94 @@
+import { Cipher } from "../Cipher.js";
+import crypto from "crypto";
+import { Buffer } from "buffer";
+export class Salsa20 extends Cipher {
+    constructor(key, nonce, counter = 0) {
+        super();
+        if (typeof key === "string")
+            key = Buffer.from(key, "base64");
+        if (typeof nonce === "string")
+            nonce = Buffer.from(nonce, "base64");
+        if (key.length !== 32)
+            throw new Error("Key must be 32 bytes (256-bit).");
+        if (nonce.length !== 8)
+            throw new Error("Nonce must be 8 bytes (64-bit).");
+        this.key = new Uint32Array(new Uint8Array(key).buffer);
+        this.nonce = new Uint32Array(new Uint8Array(nonce).buffer);
+        this.counter = counter;
+    }
+    static rotateLeft(x, n) {
+        return (x << n) | (x >>> (32 - n));
+    }
+    static quarterRound(state, a, b, c, d) {
+        state[b] ^= Salsa20.rotateLeft(state[a] + state[d], 7);
+        state[c] ^= Salsa20.rotateLeft(state[b] + state[a], 9);
+        state[d] ^= Salsa20.rotateLeft(state[c] + state[b], 13);
+        state[a] ^= Salsa20.rotateLeft(state[d] + state[c], 18);
+    }
+    generateKeystreamBlock() {
+        const constants = new Uint32Array([
+            0x61707865, 0x3320646e, 0x79622d32, 0x6b206574,
+        ]); // "expand 32-byte k"
+        const state = new Uint32Array(16);
+        state.set(constants, 0);
+        state.set(this.key.slice(0, 4), 4);
+        state.set(this.nonce, 8);
+        state.set([this.counter, 0], 10);
+        state.set(this.key.slice(4, 8), 12);
+        const workingState = new Uint32Array(state);
+        for (let i = 0; i < 10; i++) {
+            Salsa20.quarterRound(workingState, 0, 4, 8, 12);
+            Salsa20.quarterRound(workingState, 1, 5, 9, 13);
+            Salsa20.quarterRound(workingState, 2, 6, 10, 14);
+            Salsa20.quarterRound(workingState, 3, 7, 11, 15);
+            Salsa20.quarterRound(workingState, 0, 5, 10, 15);
+            Salsa20.quarterRound(workingState, 1, 6, 11, 12);
+            Salsa20.quarterRound(workingState, 2, 7, 8, 13);
+            Salsa20.quarterRound(workingState, 3, 4, 9, 14);
+        }
+        for (let i = 0; i < 16; i++) {
+            workingState[i] += state[i];
+        }
+        this.counter++; // Increment counter for next block
+        return new Uint8Array(workingState.buffer);
+    }
+    encrypt(plaintext) {
+        const textBytes = new TextEncoder().encode(plaintext);
+        const ciphertext = new Uint8Array(textBytes.length);
+        for (let i = 0; i < textBytes.length; i += 64) {
+            const keystream = this.generateKeystreamBlock();
+            const blockLength = Math.min(64, textBytes.length - i);
+            for (let j = 0; j < blockLength; j++) {
+                ciphertext[i + j] = textBytes[i + j] ^ keystream[j];
+            }
+        }
+        return Salsa20.encodeBase64(ciphertext);
+    }
+    decrypt(ciphertext) {
+        const originalCounter = this.counter;
+        this.counter = 0;
+        const cipherUnit8Array = Salsa20.decodeBase64(ciphertext);
+        const decryptedBytes = new Uint8Array(cipherUnit8Array.length);
+        for (let i = 0; i < cipherUnit8Array.length; i += 64) {
+            const keystream = this.generateKeystreamBlock();
+            const blockLength = Math.min(64, cipherUnit8Array.length - i);
+            for (let j = 0; j < blockLength; j++) {
+                decryptedBytes[i + j] = cipherUnit8Array[i + j] ^ keystream[j];
+            }
+        }
+        this.counter = originalCounter;
+        return new TextDecoder().decode(decryptedBytes);
+    }
+    static generateKey() {
+        return Salsa20.encodeBase64(crypto.getRandomValues(new Uint8Array(32)));
+    }
+    static generateNonce() {
+        return Salsa20.encodeBase64(crypto.getRandomValues(new Uint8Array(8)));
+    }
+    static encodeBase64(uint8array) {
+        return Buffer.from(uint8array).toString("base64");
+    }
+    static decodeBase64(base64) {
+        return new Uint8Array(Buffer.from(base64, "base64"));
+    }
+}

package/dist/index.js

@@ -4,9 +4,13 @@ import { Atbash } from "./ciphers/Atbash.js";
 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.3",
+  "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": {