[ADD] cypher code converters

Author: HenraL

vscode/asperheader/src/modules/ciphers/base/baseCipher.ts

@@ -0,0 +1,35 @@
+import { CipherI } from "./cipherInterface";
+
+
+export abstract class BaseCipher implements CipherI {
+    abstract encode(plaintext: string, key?: any): string;
+    abstract decode(ciphertext: string, key?: any): string;
+    abstract readonly CipherName: string;
+
+    static readonly ALPHABET: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    // Optional shared utility methods
+    protected sanitize(text: string): string {
+        return text.toUpperCase().replace(/[^A-Z]/g, '');
+    }
+
+    protected mod(n: number, m: number): number {
+        return ((n % m) + m) % m;
+    }
+
+    protected modInverse(a: number, m: number): number {
+        a = this.mod(a, m);
+        for (let x = 1; x < m; x++) {
+            if (this.mod(a * x, m) === 1) {
+                return x;
+            }
+        }
+        throw new Error("No modular inverse");
+    }
+    protected shiftChar(ch: string, shift: number): string {
+        const i = BaseCipher.ALPHABET.indexOf(ch.toUpperCase());
+        if (i === -1) {
+            return ch;
+        };
+        return BaseCipher.ALPHABET[this.mod(i + shift, 26)];
+    }
+}

vscode/asperheader/src/modules/ciphers/base/cipherInterface.ts

@@ -0,0 +1,4 @@
+export interface CipherI {
+    encode(plaintext: string, key?: string | number | any): string;
+    decode(ciphertext: string, key?: string | number | any): string;
+}

vscode/asperheader/src/modules/ciphers/base/index.ts

@@ -0,0 +1,2 @@
+export { CipherI } from "./cipherInterface";
+export { BaseCipher } from "./baseCipher";

vscode/asperheader/src/modules/ciphers/ciphers.ts

@@ -0,0 +1,125 @@
+import {
+    ADFGVXCipher, AffineCipher, AtbashCipher, AutokeyCipher,
+    BaconCipher, Base64Cipher, BaudotCipher, BeaufortCipher,
+    BifidCipher, CaesarCipher, ColumnarCipher, DoubleTranspositionCipher,
+    EnigmaCipher, FractionatedMorseCipher, GronsfeldCipher, KeywordCipher,
+    MonoalphabeticCipher, MorseBasicCipher, NihilistCipher, PigpenCipher,
+    PolybiusCipher, PortaCipher, RailFenceCipher, ROT13Cipher, RouteCipher,
+    ScytaleCipher, TapCodeCipher, TrifidCipher, VICCipher, VigenereCipher,
+    XORCipher
+} from './flavoured';
+
+
+import { BaseCipher } from "./base/baseCipher";
+
+export class Cipher {
+    private cipherMap: Record<string, BaseCipher> = {};
+
+    constructor() {
+        const cipherClasses = [
+            CaesarCipher,
+            ROT13Cipher,
+            AtbashCipher,
+            MonoalphabeticCipher,
+            KeywordCipher,
+            AffineCipher,
+            BaconCipher,
+            PolybiusCipher,
+            VigenereCipher,
+            AutokeyCipher,
+            BeaufortCipher,
+            GronsfeldCipher,
+            PortaCipher,
+            RailFenceCipher,
+            ColumnarCipher,
+            RouteCipher,
+            ScytaleCipher,
+            DoubleTranspositionCipher,
+            MorseBasicCipher,
+            PigpenCipher,
+            TapCodeCipher,
+            ADFGVXCipher,
+            FractionatedMorseCipher,
+            BaudotCipher,
+            NihilistCipher,
+            VICCipher,
+            BifidCipher,
+            TrifidCipher,
+            EnigmaCipher,
+            XORCipher,
+            Base64Cipher
+        ];
+
+        for (const CipherClass of cipherClasses) {
+            const instance = new CipherClass();
+            // Lowercase the key for case-insensitive lookup
+            this.cipherMap[this.normalize(instance.CipherName)] = instance;
+        }
+    }
+
+    private normalize(name: string): string {
+        return name.toLowerCase().replace(/\s+/g, '');
+    }
+
+    encode(plaintext: string, key?: any, cipherName?: string): string {
+        if (!cipherName) {
+            throw new Error("Cipher name required");
+        }
+        const cipher = this.cipherMap[this.normalize(cipherName)];
+        if (!cipher) {
+            throw new Error(`Cipher "${cipherName}" not found`);
+        }
+        return cipher.encode(plaintext, key);
+    }
+
+    decode(ciphertext: string, key?: any, cipherName?: string): string {
+        if (!cipherName) {
+            throw new Error("Cipher name required");
+        }
+        const cipher = this.cipherMap[this.normalize(cipherName)];
+        if (!cipher) {
+            throw new Error(`Cipher "${cipherName}" not found`);
+        }
+        return cipher.decode(ciphertext, key);
+    }
+
+    listCiphers(): string[] {
+        return Object.keys(this.cipherMap);
+    }
+}
+
+
+export const ALLCiphers = {
+    Cipher,
+    CaesarCipher,
+    ROT13Cipher,
+    AtbashCipher,
+    MonoalphabeticCipher,
+    KeywordCipher,
+    AffineCipher,
+    BaconCipher,
+    PolybiusCipher,
+    VigenereCipher,
+    AutokeyCipher,
+    BeaufortCipher,
+    GronsfeldCipher,
+    PortaCipher,
+    RailFenceCipher,
+    ColumnarCipher,
+    RouteCipher,
+    ScytaleCipher,
+    DoubleTranspositionCipher,
+    MorseBasicCipher,
+    PigpenCipher,
+    TapCodeCipher,
+    ADFGVXCipher,
+    FractionatedMorseCipher,
+    BaudotCipher,
+    NihilistCipher,
+    VICCipher,
+    BifidCipher,
+    TrifidCipher,
+    EnigmaCipher,
+    XORCipher,
+    Base64Cipher
+};

vscode/asperheader/src/modules/ciphers/flavoured/adfgvx.ts

@@ -0,0 +1,43 @@
+import { BaseCipher } from "../base/baseCipher";
+import { ColumnarCipher } from "./columnar";
+
+export class ADFGVXCipher extends BaseCipher {
+    private readonly labels = ['A', 'D', 'F', 'G', 'V', 'X'];
+    private readonly square: string[];
+
+    readonly CipherName = "ADFGVX";
+
+    constructor() {
+        super();
+        // 6x6 square with A-Z and 0-9
+        this.square = (BaseCipher.ALPHABET + '0123456789').split('');
+    }
+    encode(plainText: string = '', key: string = ''): string {
+        const clean = plainText.toUpperCase();
+        let pairs = '';
+        for (const ch of clean) {
+            const idx = this.square.indexOf(ch);
+            if (idx === -1) {
+                pairs += ch; continue;
+            }
+            const r = Math.floor(idx / 6), c = idx % 6;
+            pairs += this.labels[r] + this.labels[c];
+        }
+        // then columnar transposition
+        return new ColumnarCipher().encode(pairs, key);
+    }
+    decode(ciphertext: string = '', key: string = ''): string {
+        const pairs = new ColumnarCipher().decode(ciphertext, key).match(/../g) || [];
+        let out = '';
+        for (const p of pairs) {
+            const r = this.labels.indexOf(p[0]);
+            const c = this.labels.indexOf(p[1]);
+            if (r === -1 || c === -1) {
+                out += p;
+            } else {
+                out += this.square[r * 6 + c];
+            }
+        }
+        return out;
+    }
+}

vscode/asperheader/src/modules/ciphers/flavoured/affine.ts

@@ -0,0 +1,48 @@
+import { BaseCipher } from "../base/baseCipher";
+
+export class AffineCipher extends BaseCipher {
+    private readonly a: number;
+    private readonly b: number;
+    readonly CipherName = "Affine";
+    constructor(a: number = 5, b: number = 8) {
+        super();
+        this.a = a;
+        this.b = b;
+        if (this.gcd(this.a, 26) !== 1) {
+            throw new Error("a must be coprime with 26");
+        }
+    }
+
+    private gcd(a: number, b: number): number {
+        return b === 0 ? a : this.gcd(b, a % b);
+    }
+
+    encode(plainText: string = ""): string {
+        return plainText
+            .toUpperCase()
+            .split("")
+            .map(ch => {
+                const i = BaseCipher.ALPHABET.indexOf(ch);
+                if (i === -1) {
+                    return ch;
+                }// preserve non-letters
+                return BaseCipher.ALPHABET[this.mod(this.a * i + this.b, 26)];
+            })
+            .join("");
+    }
+
+    decode(cipherText: string = ""): string {
+        const invA = this.modInverse(this.a, 26);
+        return cipherText
+            .toUpperCase()
+            .split("")
+            .map(ch => {
+                const i = BaseCipher.ALPHABET.indexOf(ch);
+                if (i === -1) {
+                    return ch;
+                }
+                return BaseCipher.ALPHABET[this.mod(invA * (i - this.b), 26)];
+            })
+            .join("");
+    }
+}

vscode/asperheader/src/modules/ciphers/flavoured/atBash.ts

@@ -0,0 +1,28 @@
+import { BaseCipher } from "../base/baseCipher";
+
+export class AtbashCipher extends BaseCipher {
+    readonly CipherName = "Atbash";
+    private readonly map: Record<string, string>;
+
+    constructor() {
+        super();
+        this.map = {};
+
+        const alphabet = BaseCipher.ALPHABET;
+        for (let i = 0; i < alphabet.length; i++) {
+            this.map[alphabet[i]] = alphabet[alphabet.length - 1 - i];
+        }
+    }
+
+    encode(plainText: string = ""): string {
+        return plainText
+            .split("")
+            .map(ch => this.map[ch.toUpperCase()] ?? ch)
+            .join("");
+    }
+
+    decode(cipherText: string = ""): string {
+        // Atbash is symmetric — same as encode
+        return this.encode(cipherText);
+    }
+}

vscode/asperheader/src/modules/ciphers/flavoured/autoKey.ts

@@ -0,0 +1,40 @@
+import { BaseCipher } from "../base/baseCipher";
+
+export class AutokeyCipher extends BaseCipher {
+    readonly CipherName = "Autokey";
+
+    constructor() {
+        super();
+    }
+
+    encode(plainText: string = "", key: string = ""): string {
+        const cleanPT = this.sanitize(plainText);
+        const cleanKey = this.sanitize(key);
+        let fullKey = (cleanKey + cleanPT).slice(0, cleanPT.length);
+
+        let out = "";
+        for (let i = 0; i < cleanPT.length; i++) {
+            const p = BaseCipher.ALPHABET.indexOf(cleanPT[i]);
+            const k = BaseCipher.ALPHABET.indexOf(fullKey[i]);
+            out += BaseCipher.ALPHABET[this.mod(p + k, 26)];
+        }
+        return out;
+    }
+
+    decode(cipherText: string = "", key: string = ""): string {
+        const cleanCT = this.sanitize(cipherText);
+        let fullKey = this.sanitize(key).split("");
+
+        let out = "";
+        for (const ch of cleanCT) {
+            const c = BaseCipher.ALPHABET.indexOf(ch);
+            const k = BaseCipher.ALPHABET.indexOf(fullKey[0]);
+            const p = BaseCipher.ALPHABET[this.mod(c - k, 26)];
+
+            out += p;
+            fullKey.push(p); // append plaintext to key
+            fullKey.shift(); // maintain rolling window
+        }
+        return out;
+    }
+}

vscode/asperheader/src/modules/ciphers/flavoured/bacon.ts

@@ -0,0 +1,50 @@
+import { BaseCipher } from "../base/baseCipher";
+
+export class BaconCipher extends BaseCipher {
+    readonly CipherName = "Bacon";
+
+    constructor() {
+        super();
+    }
+
+    private encodeChar(ch: string): string {
+        const index = BaseCipher.ALPHABET.indexOf(ch.toUpperCase());
+        if (index === -1) {
+            return ch;
+        }
+
+        const binary = index.toString(2).padStart(5, "0");
+        return binary.replace(/0/g, "A").replace(/1/g, "B");
+    }
+
+    private decodeToken(token: string): string {
+        if (!/^[AB]{5}$/.test(token)) {
+            return token;
+        }
+
+        const binary = token.replace(/A/g, "0").replace(/B/g, "1");
+        const index = parseInt(binary, 2);
+        return BaseCipher.ALPHABET[index] ?? "?";
+    }
+
+    encode(plainText: string = ""): string {
+        const tokens: string[] = [];
+
+        for (const ch of plainText) {
+            tokens.push(this.encodeChar(ch));
+        }
+
+        return tokens.join(" ");
+    }
+
+    decode(cipherText: string = ""): string {
+        const tokens: string[] = cipherText.split(/\s+/);
+        const output: string[] = [];
+
+        for (const token of tokens) {
+            output.push(this.decodeToken(token));
+        }
+
+        return output.join("");
+    }
+}