encrypt.ts

import * as readline from 'readline';
import * as crypto from 'crypto';
import keysConfig from './keys.json';
import { 
    encryptSubstitution, 
    encryptCaesar, 
    railFenceEncrypt, 
    addHiddenPadding, 
    getKeyShifts, 
    getRepeatingShifts,
    encryptMath,
    stretchKey,
    generateHMAC,
    generateRandomSalt,
    generateRandomIV,
    deriveKeys,
    aesEncrypt,
    getPipelineOrder
} from './cipher';

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

function question(query: string): Promise<string> {
    return new Promise(resolve => rl.question(query, resolve));
}

async function main() {
    try {
        const key = await question("Enter a key: ");
        const plaintext = await question("Enter the plaintext: ");
        let numRoundsStr = await question("Enter the number of rounds for encryption: ");
        let numRounds = parseInt(numRoundsStr) || 1;

        const liveSalt = generateRandomSalt();
        const masterKeyBuffer = stretchKey(key, liveSalt);
        const { aesKey, hmacKey } = deriveKeys(masterKeyBuffer, liveSalt);
        const masterKeyHex = masterKeyBuffer.toString('hex');

        let state = plaintext;
        let iv = "";
        let tag = "";
        let hmac = "";

        const masterPipeline = (keysConfig as any).MASTER_PIPELINE;
        const legacyKeyShifts = getKeyShifts(key);
        const legacyRepeatingShifts = getRepeatingShifts(legacyKeyShifts, numRounds);

        // console.log(`\n--- STARTING ENCRYPTION PIPELINE ---`);
        // console.log(`Initial Plaintext: "${plaintext}"`);

        for (const stage of masterPipeline) {
            // console.log(`\n>>> EXECUTING STAGE: ${stage.toUpperCase()}`);
            
            if (stage === "substitution" && (keysConfig as any).ENABLE_SUBSTITUTION_LAYER) {
                // state = encryptSubstitution(state);
                // console.log(`[Substitution] Result: ${state}`);
            } else if (stage === "chaos") {
                // console.log(`Entering Chaos Layer (${numRounds} rounds)...`);
                for (let round = 0; round < numRounds; round++) {
                    const legacyRoundShift = legacyRepeatingShifts[round];
                    const roundDigest = crypto.createHash('sha256').update(masterKeyHex + round.toString() + legacyRoundShift.toString()).digest();
                    const shift = roundDigest[0];
                    const modifier = roundDigest[1];
                    const pipelineOrder = getPipelineOrder(modifier);

                    // console.log(`  [Round ${round + 1}] (Shift: ${shift}, Sequence: ${pipelineOrder.join(' -> ')})`);

                    for (const step of pipelineOrder) {
                        let stepName = "";
                        if (step === "caesar" && (keysConfig as any).ENABLE_CAESAR_LAYER) {
                            state = encryptCaesar(state, shift);
                            stepName = "Caesar";
                        } else if (step === "substitution" && (keysConfig as any).ENABLE_SUBSTITUTION_LAYER) {
                            state = encryptSubstitution(state);
                            stepName = "Substitution";
                        } else if (step === "rail_fence" && (keysConfig as any).ENABLE_RAIL_FENCE_LAYER) {
                            state = railFenceEncrypt(state);
                            stepName = "Rail Fence";
                        } else if (step === "math" && (keysConfig as any).ENABLE_MATH_LAYER) {
                            state = encryptMath(state, shift);
                            stepName = "Math (Affine)";
                        }
                        
                        // if (stepName) {
                        //     console.log(`    - ${stepName.padEnd(15)}: ${state}`);
                        // }
                    }
                }
            } else if (stage === "padding") {
                state = addHiddenPadding(state);
                // console.log(`[Padding] Result: ${state}`);
            } else if (stage === "aes" && (keysConfig as any).AES_ENABLED) {
                iv = generateRandomIV();
                const aesResult = aesEncrypt(state, aesKey, iv);
                state = aesResult.ciphertext;
                tag = aesResult.tag;
                // console.log(`[AES-256-GCM] Ciphertext: ${state}`);
                // console.log(`[AES-256-GCM] Auth Tag: ${tag}`);
            } else if (stage === "hmac" && (keysConfig as any).ENABLE_HMAC) {
                const hmacPayload = state + liveSalt + iv + tag;
                hmac = generateHMAC(hmacKey, hmacPayload);
                // console.log(`[HMAC-SHA384] Signature: ${hmac}`);
            }
        }

        // --- FINAL DETERMINISTIC NORMALIZATION ---
        // If the final stage was not AES, the payload is still a string. 
        // We must Base64 encode it once for safe transport in the JSON.
        const lastStage = masterPipeline[masterPipeline.length - 1];
        const finalData = (lastStage === "aes" && (keysConfig as any).AES_ENABLED) ? state : Buffer.from(state, 'utf16le').toString('base64');

        const payloadObj = {
            data: finalData,
            hmac,
            salt: liveSalt,
            iv,
            tag
        };

        const jsonStr = JSON.stringify(payloadObj);
        const transportSafePayload = Buffer.from(jsonStr, 'utf-8').toString('base64');

        console.log(`\nFinal secure JSON payload (Base64 wrapper): \n${transportSafePayload}\n`);
    } catch (err) {
        console.error(err);
    } finally {
        rl.close();
    }
}

main();