crypto-keygen-suite/keyGen/bases/Quantum/BB84.js

Key generation utilities for cryptographic operations. YES I RENAMED IT. SIX STATE PROTOCOL!!! See its folder for all <3

import yargs from 'yargs/yargs';
import { hideBin } from 'yargs/helpers';
import fs from 'fs';

function generateBB84Key(length, format, secure) {
    const bases = []; // Sender's basis choices (random)
    const bits = []; // Sender's raw bits (random)
    const receiverBases = []; // Receiver's basis choices (random)
    const siftedKey = []; // Matching bases form the final key

    for (let i = 0; i < length; i++) {
        bases.push(Math.random() > 0.5 ? 'X' : '+'); // Basis choice: 'X' or '+'
        bits.push(Math.random() > 0.5 ? 1 : 0); // Random bit 0 or 1
        receiverBases.push(Math.random() > 0.5 ? 'X' : '+'); // Receiver's basis
    }

    for (let i = 0; i < length; i++) {
        if (bases[i] === receiverBases[i]) {
            siftedKey.push(bits[i]);
        }
    }

    let finalKey = siftedKey.join('');

    // Convert key based on format selection
    if (format === 'hex') {
        finalKey = Buffer.from(finalKey).toString('hex');
    } else if (format === 'base64') {
        finalKey = Buffer.from(finalKey).toString('base64');
    }

    console.log(`Generated BB84 Key (${format.toUpperCase()}): ${finalKey}`);

    if (secure) {
        console.log("🔒 Secure Mode Enabled: Saving key to file.");
        fs.writeFileSync(`bb84_sifted_key.${format}`, finalKey);
    }

    return finalKey;
}

function encryptMessage(message, key, format, secure) {
    const keyBytes = Buffer.from(key.repeat(Math.ceil(message.length / key.length)), 'utf8'); // Extend key if needed
    const messageBytes = Buffer.from(message, 'utf8');

    const encrypted = messageBytes.map((byte, index) => byte ^ keyBytes[index]); // XOR encryption
    
    let encryptedOutput;
    if (format === 'hex') {
        encryptedOutput = Buffer.from(encrypted).toString('hex');
    } else if (format === 'base64') {
        encryptedOutput = Buffer.from(encrypted).toString('base64');
    } else {
        encryptedOutput = encrypted;
    }

    console.log(`Encrypted Message (${format.toUpperCase()}): ${encryptedOutput}`);

    if (secure) {
        console.log("🔒 Secure Mode Enabled: Saving encrypted message.");
        fs.writeFileSync(`bb84_encrypted_message.${format}`, encryptedOutput);
    }

    return encryptedOutput;
}

function decryptMessage(encrypted, key, format, secure) {
    if (format !== 'raw') {
        encrypted = Buffer.from(encrypted, format);
    }

    const keyBytes = Buffer.from(key.repeat(Math.ceil(encrypted.length / key.length)), 'utf8');
    const decrypted = encrypted.map((byte, index) => byte ^ keyBytes[index]);

    let decryptedMessage = Buffer.from(decrypted).toString();

    console.log(`Decrypted Message: ${decryptedMessage}`);

    if (secure) {
        console.log("🔒 Secure Mode Enabled: Saving decrypted message.");
        fs.writeFileSync(`bb84_decrypted_message.txt`, decryptedMessage);
    }

    return decryptedMessage;
}

// CLI Setup
async function main() {
    const argv = yargs(hideBin(process.argv))
        .option('mode', {
            alias: 'm',
            type: 'string',
            choices: ['generate', 'encrypt', 'decrypt'],
            describe: 'Choose operation mode: generate key, encrypt, or decrypt',
        })
        .option('length', {
            alias: 'l',
            type: 'number',
            default: 16,
            describe: 'Length of the key (only for generation)',
        })
        .option('message', {
            alias: 'msg',
            type: 'string',
            describe: 'Message to encrypt or decrypt (requires a key)',
        })
        .option('key', {
            alias: 'k',
            type: 'string',
            describe: 'Key for encryption/decryption',
        })
        .option('format', {
            alias: 'f',
            type: 'string',
            default: 'raw',
            choices: ['raw', 'hex', 'base64'],
            describe: 'Choose output format (raw, hex, base64)',
        })
        .help()
        .argv;

    if (argv.mode === 'generate') {
        generateBB84Key(argv.length, argv.format, argv.secure);
    } else if (argv.mode === 'encrypt') {
        if (!argv.message || !argv.key) {
            console.error('Encryption requires both a message and a key.');
            return;
        }
        encryptMessage(argv.message, argv.key, argv.format, argv.secure);
    } else if (argv.mode === 'decrypt') {
        if (!argv.message || !argv.key) {
            console.error('Decryption requires both an encrypted message and a key.');
            return;
        }
        decryptMessage(argv.message, argv.key, argv.format, argv.secure);
    } else {
        console.error('Invalid mode. Use --mode generate | encrypt | decrypt');
    }
}

console.log("🚀 Debug: Running main function...");
main();