@irfanshadikrishad/cipher 1.4.1 → 1.5.1

package/README.md

@@ -43,19 +43,20 @@ 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          |
-| [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 |
-| [ECC](/docs/en/ciphers/ECC.md)                      | Asymmetric (Public-Key Cryptography)     | Yes           | Very High | Used in modern systems like Bitcoin, TLS, JWT, etc. |
-| [ROT13](/docs/en/ciphers/ROT13.md)                  | Substitution (Caesar variant)            | No            | Very Low  | Simple text obfuscation, not secure                 |
+| 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   |
+| [ECC](/docs/en/ciphers/ECC.md)                      | Asymmetric (Public-Key Cryptography)     | Yes           | Very High | Used in modern systems like Bitcoin, TLS, JWT, etc.   |
+| [ROT13](/docs/en/ciphers/ROT13.md)                  | Substitution (Caesar variant)            | No            | Very Low  | Simple text obfuscation, not secure                   |
+| [Nihilist](/docs/en/ciphers/Nihilist.md)            | Polybius Square + Addition               | Yes           | Medium    | Used by Russian Nihilists, Polybius + additive cipher |
 
 More ciphers coming soon...
 

package/dist/Cipher.d.ts

@@ -5,6 +5,7 @@ import { Atbash } from './ciphers/Atbash.js';
 import { Caesar } from './ciphers/Caesar.js';
 import { DES } from './ciphers/DES.js';
 import { ECC } from './ciphers/ECC.js';
+import { Nihilist } from './ciphers/Nihilist.js';
 import { Playfair } from './ciphers/Playfair.js';
 import { ROT13 } from './ciphers/ROT13.js';
 import { Salsa20 } from './ciphers/Salsa20.js';
@@ -68,6 +69,10 @@ export declare abstract class Cipher {
      * ROT13 is a simple letter substitution cipher that replaces a letter with the 13th letter after it in the Latin alphabet.
      */
     static ROT13: typeof ROT13;
+    /**
+     * Nihilist cipher is a manually operated symmetric encryption cipher, originally used by Russian Nihilists in the 1880s to organize terrorism against the tsarist regime.
+     */
+    static Nihilist: typeof Nihilist;
     abstract encrypt(text: string): string | Promise<string>;
     abstract decrypt(text: string): string | Promise<string>;
 }

package/dist/ciphers/ECC.d.ts

@@ -1,15 +1,18 @@
+import { webcrypto } from 'node:crypto';
 import { Cipher } from '../Cipher.js';
+type NodeCryptoKey = webcrypto.CryptoKey;
 export declare class ECC extends Cipher {
     private recipientPublicKey?;
     private ownPrivateKey?;
     static recipientPublicKey: string;
     static ownPrivateKey: string;
-    constructor(recipientPublicKey?: CryptoKey, ownPrivateKey?: CryptoKey);
+    constructor(recipientPublicKey?: NodeCryptoKey, ownPrivateKey?: NodeCryptoKey);
     static generate(): Promise<ECC>;
     encrypt(plaintext: string): Promise<string>;
     decrypt(data: string): Promise<string>;
     exportPublicKey(): Promise<string>;
-    static importPublicKey(hex: string): Promise<CryptoKey>;
+    static importPublicKey(hex: string): Promise<NodeCryptoKey>;
     static bufToHex(buf: Uint8Array): string;
-    static hexToBuf(hex: string): Uint8Array;
+    static hexToBuf(hex: string): ArrayBuffer;
 }
+export {};

package/dist/ciphers/ECC.js

@@ -1,5 +1,6 @@
-import crypto from 'crypto';
+import { webcrypto } from 'node:crypto';
 import { Cipher } from '../Cipher.js';
+const crypto = webcrypto;
 export class ECC extends Cipher {
     constructor(recipientPublicKey, ownPrivateKey) {
         super();
@@ -11,8 +12,9 @@ export class ECC extends Cipher {
         return new ECC(publicKey, privateKey);
     }
     async encrypt(plaintext) {
-        if (!this.recipientPublicKey)
+        if (!this.recipientPublicKey) {
             throw new Error('Recipient public key not set');
+        }
         const ephemeral = await ECC.generate();
         const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: this.recipientPublicKey }, ephemeral.ownPrivateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
         const iv = crypto.getRandomValues(new Uint8Array(12));
@@ -25,31 +27,35 @@ export class ECC extends Cipher {
         return JSON.stringify(payload);
     }
     async decrypt(data) {
-        if (!this.ownPrivateKey)
+        if (!this.ownPrivateKey) {
             throw new Error('Own private key not set');
+        }
         const { iv, ciphertext, ephemeralPublicHex } = JSON.parse(data);
         const ephemeralPubKey = await ECC.importPublicKey(ephemeralPublicHex);
         const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: ephemeralPubKey }, this.ownPrivateKey, { name: 'AES-GCM', length: 256 }, false, ['decrypt']);
-        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: ECC.hexToBuf(iv) }, sharedKey, ECC.hexToBuf(ciphertext));
+        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: new Uint8Array(ECC.hexToBuf(iv)) }, sharedKey, ECC.hexToBuf(ciphertext));
         return new TextDecoder().decode(decrypted);
     }
     async exportPublicKey() {
-        const raw = await crypto.subtle.exportKey('raw', this.recipientPublicKey || this.ownPrivateKey);
+        const key = this.recipientPublicKey ?? this.ownPrivateKey;
+        if (!key) {
+            throw new Error('No key available to export');
+        }
+        const raw = await crypto.subtle.exportKey('raw', key);
         return ECC.bufToHex(new Uint8Array(raw));
     }
     static async importPublicKey(hex) {
-        const raw = ECC.hexToBuf(hex);
-        return crypto.subtle.importKey('raw', raw, { name: 'ECDH', namedCurve: 'P-256' }, true, []);
+        return crypto.subtle.importKey('raw', ECC.hexToBuf(hex), { name: 'ECDH', namedCurve: 'P-256' }, true, []);
     }
-    // Helpers
+    // ===== Helpers =====
     static bufToHex(buf) {
         return [...buf].map((b) => b.toString(16).padStart(2, '0')).join('');
     }
     static hexToBuf(hex) {
         const bytes = new Uint8Array(hex.length / 2);
         for (let i = 0; i < bytes.length; i++) {
-            bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+            bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
         }
-        return bytes;
+        return bytes.buffer;
     }
 }

package/dist/ciphers/Nihilist.d.ts

@@ -0,0 +1,12 @@
+import { Cipher } from '../Cipher.js';
+export declare class Nihilist extends Cipher {
+    private key;
+    private keyword;
+    constructor(key: string, keyword: string);
+    private prepareKey;
+    private getCoordinates;
+    private textToNumbers;
+    private numbersToText;
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+}

package/dist/ciphers/Nihilist.js

@@ -0,0 +1,109 @@
+import { Cipher } from '../Cipher.js';
+export class Nihilist extends Cipher {
+    constructor(key, keyword) {
+        super();
+        this.key = this.prepareKey(key.toUpperCase().replace(/[^A-Z]/g, ''));
+        this.keyword = keyword.toUpperCase().replace(/[^A-Z]/g, '');
+    }
+    prepareKey(key) {
+        const alphabet = 'ABCDEFGHIKLMNOPQRSTUVWXYZ'; // I/J combined
+        let result = '';
+        const seen = new Set();
+        // Add key letters first
+        for (const char of key) {
+            const normalizedChar = char === 'J' ? 'I' : char;
+            if (!seen.has(normalizedChar)) {
+                result += normalizedChar;
+                seen.add(normalizedChar);
+            }
+        }
+        // Add remaining alphabet letters
+        for (const char of alphabet) {
+            if (!seen.has(char)) {
+                result += char;
+                seen.add(char);
+            }
+        }
+        return result;
+    }
+    getCoordinates(text) {
+        const normalizedText = text
+            .toUpperCase()
+            .replace(/J/g, 'I')
+            .replace(/[^A-Z]/g, '');
+        const coordinates = [];
+        for (const char of normalizedText) {
+            const index = this.key.indexOf(char);
+            if (index !== -1) {
+                const row = Math.floor(index / 5) + 1;
+                const col = (index % 5) + 1;
+                coordinates.push(row, col);
+            }
+        }
+        return coordinates;
+    }
+    textToNumbers(text) {
+        const coordinates = this.getCoordinates(text);
+        const numbers = [];
+        for (let i = 0; i < coordinates.length; i += 2) {
+            numbers.push(coordinates[i] * 10 + coordinates[i + 1]);
+        }
+        return numbers;
+    }
+    numbersToText(numbers) {
+        let result = '';
+        for (const num of numbers) {
+            const row = Math.floor(num / 10) - 1;
+            const col = (num % 10) - 1;
+            if (row >= 0 && row < 5 && col >= 0 && col < 5) {
+                const index = row * 5 + col;
+                result += this.key.charAt(index);
+            }
+        }
+        return result;
+    }
+    encrypt(plaintext) {
+        if (!plaintext)
+            return '';
+        // Convert plaintext to numbers
+        const plaintextNumbers = this.textToNumbers(plaintext);
+        if (plaintextNumbers.length === 0)
+            return '';
+        // Convert keyword to numbers
+        const keywordNumbers = this.textToNumbers(this.keyword);
+        if (keywordNumbers.length === 0) {
+            return plaintextNumbers.join(' ');
+        }
+        // Add plaintext and repeated keyword numbers
+        const cipherNumbers = [];
+        for (let i = 0; i < plaintextNumbers.length; i++) {
+            const keywordNum = keywordNumbers[i % keywordNumbers.length];
+            cipherNumbers.push(plaintextNumbers[i] + keywordNum);
+        }
+        return cipherNumbers.join(' ');
+    }
+    decrypt(ciphertext) {
+        if (!ciphertext.trim())
+            return '';
+        // Parse cipher numbers, handle multiple spaces
+        const cipherNumbers = ciphertext
+            .trim()
+            .split(/\s+/)
+            .map(Number)
+            .filter((n) => !isNaN(n));
+        if (cipherNumbers.length === 0)
+            return '';
+        // Convert keyword to numbers
+        const keywordNumbers = this.textToNumbers(this.keyword);
+        if (keywordNumbers.length === 0) {
+            return this.numbersToText(cipherNumbers);
+        }
+        // Subtract keyword numbers from cipher numbers
+        const plaintextNumbers = [];
+        for (let i = 0; i < cipherNumbers.length; i++) {
+            const keywordNum = keywordNumbers[i % keywordNumbers.length];
+            plaintextNumbers.push(cipherNumbers[i] - keywordNum);
+        }
+        return this.numbersToText(plaintextNumbers);
+    }
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { Atbash } from './ciphers/Atbash.js';
 import { Caesar } from './ciphers/Caesar.js';
 import { DES } from './ciphers/DES.js';
 import { ECC } from './ciphers/ECC.js';
+import { Nihilist } from './ciphers/Nihilist.js';
 import { Playfair } from './ciphers/Playfair.js';
 import { ROT13 } from './ciphers/ROT13.js';
 import { Salsa20 } from './ciphers/Salsa20.js';
@@ -21,4 +22,5 @@ Cipher.AES = AES;
 Cipher.DES = DES;
 Cipher.ECC = ECC;
 Cipher.ROT13 = ROT13;
+Cipher.Nihilist = Nihilist;
 export { Cipher };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@irfanshadikrishad/cipher",
   "description": "A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications with zero/0 dependencies.",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "author": {
     "name": "Irfan Shadik Rishad"
   },
@@ -45,19 +45,20 @@
   ],
   "prettier": "@irfanshadikrishad/prettier",
   "devDependencies": {
-    "@eslint/js": "^9.32.0",
-    "@irfanshadikrishad/prettier": "^1.2.3",
+    "@eslint/js": "^9.39.2",
+    "@irfanshadikrishad/prettier": "^1.3.1",
     "@types/jest": "^30.0.0",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "@typescript-eslint/parser": "^8.38.0",
-    "eslint": "^9.34.0",
-    "globals": "^16.5.0",
+    "@types/node": "^25.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/parser": "^8.54.0",
+    "eslint": "^9.39.2",
+    "globals": "^17.2.0",
     "husky": "^9.1.7",
     "jest": "^30.2.0",
-    "prettier": "^3.6.2",
-    "ts-jest": "^29.4.5",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.38.0"
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0"
   },
   "publishConfig": {
     "access": "public"