@irfanshadikrishad/cipher 1.0.2 → 1.0.4

package/README.md

@@ -2,27 +2,62 @@
 
 A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications.
 
-#### Installation
+#### 🚀 Installation
+
+Install the package via npm:
+
+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 |
+
+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
+If you find this library useful, consider giving it a ⭐ on GitHub!
 
-#### Thanks for visiting (>'-'<)
+Thanks for visiting! (>'-'<)

package/dist/Cipher.d.ts

@@ -2,11 +2,41 @@ import { Caesar } from "./ciphers/Caesar.js";
 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";
 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;
-    abstract encrypt(text: string): string;
-    abstract decrypt(text: string): string;
+    /**
+     * "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;
+    /**
+     * 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;
+    abstract encrypt(text: string): string | Uint8Array;
+    abstract decrypt(text: string | Uint8Array): string;
 }

package/dist/ciphers/Alphabet.d.ts

@@ -0,0 +1,22 @@
+import { Cipher } from "../Cipher.js";
+export declare class Alphabet extends Cipher {
+    private keyword;
+    private static alphabet;
+    constructor(keyword: string);
+    /**
+     * Encrypts a message using the Alphabet Cipher.
+     * @param message - The plaintext message to encrypt.
+     * @returns The encrypted ciphertext.
+     */
+    encrypt(message: string): string;
+    /**
+     * Decrypts a message using the Alphabet Cipher.
+     * @param ciphertext - The encrypted message to decrypt.
+     * @returns The original plaintext message.
+     */
+    decrypt(ciphertext: string): string;
+    /**
+     * Generates the Vigenère table for encoding and decoding.
+     */
+    private static getVigenereTable;
+}

package/dist/ciphers/Alphabet.js

@@ -0,0 +1,65 @@
+import { Cipher } from "../Cipher.js";
+export class Alphabet extends Cipher {
+    constructor(keyword) {
+        super();
+        this.keyword = keyword.toLowerCase();
+    }
+    /**
+     * Encrypts a message using the Alphabet Cipher.
+     * @param message - The plaintext message to encrypt.
+     * @returns The encrypted ciphertext.
+     */
+    encrypt(message) {
+        message = message.toLowerCase();
+        const table = Alphabet.getVigenereTable();
+        let result = "";
+        for (let i = 0; i < message.length; i++) {
+            const msgChar = message[i];
+            const keyChar = this.keyword[i % this.keyword.length];
+            if (!Alphabet.alphabet.includes(msgChar)) {
+                result += msgChar; // Preserve non-alphabet characters
+                continue;
+            }
+            const row = Alphabet.alphabet.indexOf(keyChar);
+            const col = Alphabet.alphabet.indexOf(msgChar);
+            result += table[row][col];
+        }
+        return result;
+    }
+    /**
+     * Decrypts a message using the Alphabet Cipher.
+     * @param ciphertext - The encrypted message to decrypt.
+     * @returns The original plaintext message.
+     */
+    decrypt(ciphertext) {
+        ciphertext = ciphertext.toLowerCase();
+        const table = Alphabet.getVigenereTable();
+        let result = "";
+        for (let i = 0; i < ciphertext.length; i++) {
+            const cipherChar = ciphertext[i];
+            const keyChar = this.keyword[i % this.keyword.length];
+            if (!Alphabet.alphabet.includes(cipherChar)) {
+                result += cipherChar; // Preserve non-alphabet characters
+                continue;
+            }
+            const row = Alphabet.alphabet.indexOf(keyChar);
+            const col = table[row].indexOf(cipherChar);
+            result += Alphabet.alphabet[col];
+        }
+        return result;
+    }
+    /**
+     * Generates the Vigenère table for encoding and decoding.
+     */
+    static getVigenereTable() {
+        const table = [];
+        for (let i = 0; i < 26; i++) {
+            table[i] = Alphabet.alphabet
+                .slice(i)
+                .split("")
+                .concat(Alphabet.alphabet.slice(0, i).split(""));
+        }
+        return table;
+    }
+}
+Alphabet.alphabet = "abcdefghijklmnopqrstuvwxyz";

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

@@ -3,8 +3,12 @@ import { Caesar } from "./ciphers/Caesar.js";
 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";
 Cipher.Caesar = Caesar;
 Cipher.Atbash = Atbash;
 Cipher.Playfair = Playfair;
 Cipher.Vigenere = Vigenere;
+Cipher.Alphabet = Alphabet;
+Cipher.Salsa20 = Salsa20;
 export { Cipher };

package/package.json

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