scripts.js

"use strict";

// Rate limiting variables
let requestCount = 0;
const REQUEST_LIMIT = 5; // Max requests allowed in a minute
const TIME_FRAME = 60000; // Time frame in milliseconds

function rateLimit() {
    requestCount++;
    if (requestCount > REQUEST_LIMIT) {
        alert("Too many requests. Please try again later.");
        return false; // Block the action
    }
    setTimeout(() => {
        requestCount = 0; // Reset count after the time frame
    }, TIME_FRAME);
    return true; // Allow the action
}

// Strength Meter colors
const strengthColors = ['red', 'orange', 'yellow', 'green'];

function checkPasswordStrength() {
    const password = document.getElementById('encryptPassword').value;
    const message = document.getElementById('passwordStrengthMessage');
    const meter = document.getElementById('passwordStrengthMeter');

    const strength = calculatePasswordStrength(password);
    const width = (strength * 100) + '%';
    meter.style.width = width;

    if (strength < 0.5) {
        message.textContent = "Weak password. Please strengthen it.";
        message.style.color = 'red';
        meter.style.backgroundColor = strengthColors[0];
    } else if (strength < 0.75) {
        message.textContent = "Moderate password. Consider making it stronger.";
        message.style.color = 'orange';
        meter.style.backgroundColor = strengthColors[1];
    } else {
        message.textContent = "Strong password!";
        message.style.color = 'green';
        meter.style.backgroundColor = strengthColors[3];
    }
}

function calculatePasswordStrength(password) {
    let score = 0;
    const criteria = [
        /.{16,}/,               // At least 16 characters
        /[a-z]/,                // Lowercase
        /[A-Z]/,                // Uppercase
        /\d/,                   // Number
        /[!@#$%^&*(),.?":{}|<>]/ // Special character
    ];
    criteria.forEach((regex) => {
        if (regex.test(password)) {
            score += 0.2;
        }
    });
    return score;
}

async function deriveKeyHKDF(password, salt) {
    const enc = new TextEncoder();
    const keyMaterial = await window.crypto.subtle.importKey(
        'raw',
        enc.encode(password),
        { name: 'PBKDF2' },
        false,
        ['deriveKey']
    );
    return await window.crypto.subtle.deriveKey(
        {
            name: 'PBKDF2',
            salt: salt,
            iterations: 200000, // Increased iterations for stronger key derivation
            hash: 'SHA-256',
        },
        keyMaterial,
        { name: 'AES-GCM', length: 256 },
        false,
        ['encrypt', 'decrypt']
    );
}

async function encryptMessage() {
    if (!rateLimit()) return; // Check rate limit

    const password = document.getElementById('encryptPassword').value;
    const message = document.getElementById('message').value;

    // Create salt and IV
    const salt = window.crypto.getRandomValues(new Uint8Array(16));
    const iv = window.crypto.getRandomValues(new Uint8Array(12));

    // Derive the encryption key
    const key = await deriveKeyHKDF(password, salt);

    // Encode the message
    const enc = new TextEncoder();
    const ciphertext = await window.crypto.subtle.encrypt(
        {
            name: 'AES-GCM',
            iv: iv,
        },
        key,
        enc.encode(message)
    );

    // Derive a separate key for HMAC
    const hmacKey = await window.crypto.subtle.importKey(
        'raw',
        enc.encode(password),
        { name: 'HMAC', hash: 'SHA-256' },
        false,
        ['sign']
    );

    // Create HMAC for integrity check
    const hmac = await window.crypto.subtle.sign('HMAC', hmacKey, ciphertext);

    // Combine salt, IV, HMAC, and ciphertext into the result buffer
    const resultBuffer = new Uint8Array(
        salt.byteLength + iv.byteLength + hmac.byteLength + ciphertext.byteLength
    );
    resultBuffer.set(salt, 0);
    resultBuffer.set(iv, salt.byteLength);
    resultBuffer.set(new Uint8Array(hmac), salt.byteLength + iv.byteLength);
    resultBuffer.set(new Uint8Array(ciphertext), salt.byteLength + iv.byteLength + hmac.byteLength);

    // Encode the result into a base64 string
    document.getElementById('encryptResult').value = btoa(String.fromCharCode.apply(null, resultBuffer));

    // Clear the password and message from memory for security reasons
    clearSensitiveData(['encryptPassword', 'message']);
}

async function decryptMessage() {
    if (!rateLimit()) return; // Check rate limit

    const password = document.getElementById('decryptPassword').value;
    const result = document.getElementById('encryptedMessage').value;

    if (!result) {
        alert('Please enter an encrypted message to decrypt.');
        return;
    }

    // Decode the base64 result back into a Uint8Array
    const data = new Uint8Array(atob(result).split("").map(char => char.charCodeAt(0)));

    // Extract salt, IV, HMAC, and ciphertext
    const salt = data.slice(0, 16);
    const iv = data.slice(16, 28);
    const hmac = data.slice(28, 60);
    const ciphertext = data.slice(60);

    // Derive the encryption key from the password and salt
    const key = await deriveKeyHKDF(password, salt);

    // Import HMAC key for verification
    const hmacKey = await window.crypto.subtle.importKey(
        'raw',
        new TextEncoder().encode(password),
        { name: 'HMAC', hash: 'SHA-256' },
        false,
        ['verify']
    );

    // Verify the HMAC to ensure integrity
    const isValidHmac = await window.crypto.subtle.verify(
        'HMAC',
        hmacKey,
        hmac,
        ciphertext
    );

    if (!isValidHmac) {
        alert('Message authentication failed! The data may have been tampered with.');
        return;
    }

    // Decrypt the ciphertext
    try {
        const decryptedMessage = await window.crypto.subtle.decrypt(
            {
                name: 'AES-GCM',
                iv: iv,
            },
            key,
            ciphertext
        );

        const dec = new TextDecoder();
        document.getElementById('decryptResult').value = dec.decode(decryptedMessage);
    } catch (e) {
        alert('Decryption failed. Invalid password or corrupted message.');
    }

    // Clear the password and encrypted message from memory for security reasons
    clearSensitiveData(['decryptPassword', 'encryptedMessage']);
}

function clearSensitiveData(ids) {
    ids.forEach(id => {
        const element = document.getElementById(id);
        if (element) {
            element.value = '';
        }
    });
}

document.getElementById('encryptButton').addEventListener('click', encryptMessage);
document.getElementById('decryptButton').addEventListener('click', decryptMessage);
document.getElementById('showDecrypt').addEventListener('click', function() {
    document.getElementById('encryptSection').classList.add('hidden');
    document.getElementById('decryptSection').classList.remove('hidden');
});
document.getElementById('showEncrypt').addEventListener('click', function() {
    document.getElementById('decryptSection').classList.add('hidden');
    document.getElementById('encryptSection').classList.remove('hidden');
});