What happens if I lose my encryption key?

Without the correct key, encrypted data cannot be recovered. Always securely backup your keys and consider key escrow for critical business data. Use strong, memorable passwords or secure key management systems.

JavaScript Encryption/Decryption:

class TextEncryption {
  constructor() {
    this.supportedAlgorithms = {
      'AES-256-GCM': { keyLength: 32, ivLength: 12 },
      'AES-192-GCM': { keyLength: 24, ivLength: 12 },
      'AES-128-GCM': { keyLength: 16, ivLength: 12 },
      'AES-256-CBC': { keyLength: 32, ivLength: 16 },
      'AES-192-CBC': { keyLength: 24, ivLength: 16 },
      'AES-128-CBC': { keyLength: 16, ivLength: 16 }
    };
  }
  
  // Encrypt text using AES
  async encryptAES(plaintext, password, algorithm = 'AES-256-GCM') {
    try {
      if (!this.supportedAlgorithms[algorithm]) {
        return {
          success: false,
          error: `Unsupported algorithm: ${algorithm}`
        };
      }
      
      const config = this.supportedAlgorithms[algorithm];
      
      // Derive key from password
      const key = await this.deriveKey(password, config.keyLength);
      
      // Generate random IV
      const iv = crypto.getRandomValues(new Uint8Array(config.ivLength));
      
      // Encrypt the data
      const encoder = new TextEncoder();
      const data = encoder.encode(plaintext);
      
      const cryptoKey = await crypto.subtle.importKey(
        'raw',
        key,
        { name: algorithm.split('-')[0] },
        false,
        ['encrypt']
      );
      
      const encrypted = await crypto.subtle.encrypt(
        {
          name: algorithm.includes('GCM') ? 'AES-GCM' : 'AES-CBC',
          iv: iv
        },
        cryptoKey,
        data
      );
      
      // Combine IV and encrypted data
      const result = new Uint8Array(iv.length + encrypted.byteLength);
      result.set(iv);
      result.set(new Uint8Array(encrypted), iv.length);
      
      // Encode to Base64
      const base64Result = this.arrayBufferToBase64(result);
      
      return {
        success: true,
        encrypted: base64Result,
        algorithm: algorithm,
        keyLength: config.keyLength * 8,
        ivLength: config.ivLength,
        format: 'Base64',
        metadata: {
          timestamp: new Date().toISOString(),
          version: '1.0'
        }
      };
      
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // Decrypt AES encrypted text
  async decryptAES(encryptedData, password, algorithm = 'AES-256-GCM') {
    try {
      if (!this.supportedAlgorithms[algorithm]) {
        return {
          success: false,
          error: `Unsupported algorithm: ${algorithm}`
        };
      }
      
      const config = this.supportedAlgorithms[algorithm];
      
      // Decode from Base64
      const encrypted = this.base64ToArrayBuffer(encryptedData);
      
      // Extract IV and ciphertext
      const iv = encrypted.slice(0, config.ivLength);
      const ciphertext = encrypted.slice(config.ivLength);
      
      // Derive the same key from password
      const key = await this.deriveKey(password, config.keyLength);
      
      const cryptoKey = await crypto.subtle.importKey(
        'raw',
        key,
        { name: algorithm.split('-')[0] },
        false,
        ['decrypt']
      );
      
      // Decrypt the data
      const decrypted = await crypto.subtle.decrypt(
        {
          name: algorithm.includes('GCM') ? 'AES-GCM' : 'AES-CBC',
          iv: iv
        },
        cryptoKey,
        ciphertext
      );
      
      // Convert back to text
      const decoder = new TextDecoder();
      const plaintext = decoder.decode(decrypted);
      
      return {
        success: true,
        decrypted: plaintext,
        algorithm: algorithm,
        originalLength: plaintext.length
      };
      
    } catch (error) {
      return {
        success: false,
        error: 'Decryption failed - incorrect password or corrupted data'
      };
    }
  }
  
  // Generate RSA key pair
  async generateRSAKeyPair(keySize = 2048) {
    try {
      const keyPair = await crypto.subtle.generateKey(
        {
          name: 'RSA-OAEP',
          modulusLength: keySize,
          publicExponent: new Uint8Array([1, 0, 1]), // 65537
          hash: 'SHA-256'
        },
        true,
        ['encrypt', 'decrypt']
      );
      
      // Export keys
      const publicKey = await crypto.subtle.exportKey('spki', keyPair.publicKey);
      const privateKey = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
      
      return {
        success: true,
        publicKey: this.arrayBufferToBase64(publicKey),
        privateKey: this.arrayBufferToBase64(privateKey),
        keySize: keySize,
        format: 'Base64',
        algorithm: 'RSA-OAEP',
        hash: 'SHA-256'
      };
      
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // Encrypt with RSA public key
  async encryptRSA(plaintext, publicKeyBase64) {
    try {
      // Import public key
      const publicKeyBuffer = this.base64ToArrayBuffer(publicKeyBase64);
      const publicKey = await crypto.subtle.importKey(
        'spki',
        publicKeyBuffer,
        {
          name: 'RSA-OAEP',
          hash: 'SHA-256'
        },
        false,
        ['encrypt']
      );
      
      // Encrypt data
      const encoder = new TextEncoder();
      const data = encoder.encode(plaintext);
      
      const encrypted = await crypto.subtle.encrypt(
        'RSA-OAEP',
        publicKey,
        data
      );
      
      return {
        success: true,
        encrypted: this.arrayBufferToBase64(encrypted),
        algorithm: 'RSA-OAEP',
        hash: 'SHA-256',
        format: 'Base64'
      };
      
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // Decrypt with RSA private key
  async decryptRSA(encryptedData, privateKeyBase64) {
    try {
      // Import private key
      const privateKeyBuffer = this.base64ToArrayBuffer(privateKeyBase64);
      const privateKey = await crypto.subtle.importKey(
        'pkcs8',
        privateKeyBuffer,
        {
          name: 'RSA-OAEP',
          hash: 'SHA-256'
        },
        false,
        ['decrypt']
      );
      
      // Decrypt data
      const encryptedBuffer = this.base64ToArrayBuffer(encryptedData);
      const decrypted = await crypto.subtle.decrypt(
        'RSA-OAEP',
        privateKey,
        encryptedBuffer
      );
      
      const decoder = new TextDecoder();
      const plaintext = decoder.decode(decrypted);
      
      return {
        success: true,
        decrypted: plaintext,
        algorithm: 'RSA-OAEP'
      };
      
    } catch (error) {
      return {
        success: false,
        error: 'Decryption failed - invalid key or corrupted data'
      };
    }
  }
  
  // Derive key from password using PBKDF2
  async deriveKey(password, keyLength, iterations = 100000) {
    const encoder = new TextEncoder();
    const passwordBuffer = encoder.encode(password);
    
    // Generate random salt
    const salt = crypto.getRandomValues(new Uint8Array(16));
    
    // Import password as key material
    const keyMaterial = await crypto.subtle.importKey(
      'raw',
      passwordBuffer,
      'PBKDF2',
      false,
      ['deriveBits']
    );
    
    // Derive key
    const derivedKey = await crypto.subtle.deriveBits(
      {
        name: 'PBKDF2',
        salt: salt,
        iterations: iterations,
        hash: 'SHA-256'
      },
      keyMaterial,
      keyLength * 8
    );
    
    return new Uint8Array(derivedKey);
  }
  
  // Secure random key generation
  generateRandomKey(length = 32) {
    const key = crypto.getRandomValues(new Uint8Array(length));
    return {
      key: Array.from(key),
      keyHex: Array.from(key).map(b => b.toString(16).padStart(2, '0')).join(''),
      keyBase64: this.arrayBufferToBase64(key),
      length: length,
      bits: length * 8
    };
  }
  
  // Utility: Array Buffer to Base64
  arrayBufferToBase64(buffer) {
    const bytes = new Uint8Array(buffer);
    let binary = '';
    for (let i = 0; i < bytes.byteLength; i++) {
      binary += String.fromCharCode(bytes[i]);
    }
    return btoa(binary);
  }
  
  // Utility: Base64 to Array Buffer
  base64ToArrayBuffer(base64) {
    const binaryString = atob(base64);
    const bytes = new Uint8Array(binaryString.length);
    for (let i = 0; i < binaryString.length; i++) {
      bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes;
  }
  
  // Simple Caesar cipher (for educational purposes)
  encryptCaesar(text, shift = 3) {
    return text.replace(/[a-zA-Z]/g, char => {
      const start = char <= 'Z' ? 65 : 97;
      return String.fromCharCode((char.charCodeAt(0) - start + shift) % 26 + start);
    });
  }
  
  // Decrypt Caesar cipher
  decryptCaesar(text, shift = 3) {
    return this.encryptCaesar(text, 26 - shift);
  }
  
  // ROT13 encoding/decoding
  rot13(text) {
    return text.replace(/[a-zA-Z]/g, char => {
      const start = char <= 'Z' ? 65 : 97;
      return String.fromCharCode((char.charCodeAt(0) - start + 13) % 26 + start);
    });
  }
  
  // Base64 encoding/decoding
  base64Encode(text) {
    return btoa(unescape(encodeURIComponent(text)));
  }
  
  base64Decode(base64) {
    try {
      return decodeURIComponent(escape(atob(base64)));
    } catch (error) {
      throw new Error('Invalid Base64 encoding');
    }
  }
  
  // XOR cipher
  encryptXOR(text, key) {
    let result = '';
    for (let i = 0; i < text.length; i++) {
      const textChar = text.charCodeAt(i);
      const keyChar = key.charCodeAt(i % key.length);
      result += String.fromCharCode(textChar ^ keyChar);
    }
    return btoa(result);
  }
  
  decryptXOR(encryptedText, key) {
    const text = atob(encryptedText);
    let result = '';
    for (let i = 0; i < text.length; i++) {
      const textChar = text.charCodeAt(i);
      const keyChar = key.charCodeAt(i % key.length);
      result += String.fromCharCode(textChar ^ keyChar);
    }
    return result;
  }
  
  // Analyze encryption strength
  analyzeStrength(algorithm, keySize) {
    const analysis = {
      algorithm: algorithm,
      keySize: keySize,
      strength: 'Unknown',
      recommendation: '',
      breakTime: 'Unknown'
    };
    
    if (algorithm.includes('AES-256')) {
      analysis.strength = 'Very Strong';
      analysis.breakTime = '2^255 years (practically unbreakable)';
      analysis.recommendation = 'Excellent choice for all security needs';
    } else if (algorithm.includes('AES-128')) {
      analysis.strength = 'Strong';
      analysis.breakTime = '2^127 years (very secure)';
      analysis.recommendation = 'Good for most applications';
    } else if (algorithm.includes('RSA') && keySize >= 2048) {
      analysis.strength = 'Strong';
      analysis.breakTime = 'Decades with current technology';
      analysis.recommendation = 'Secure for current standards';
    } else if (algorithm === 'Caesar') {
      analysis.strength = 'Very Weak';
      analysis.breakTime = 'Minutes (26 possibilities)';
      analysis.recommendation = 'Only for educational purposes';
    }
    
    return analysis;
  }
  
  // Encrypt with multiple algorithms (layered encryption)
  async encryptLayered(plaintext, passwords, algorithms = ['AES-256-GCM']) {
    let currentText = plaintext;
    const layers = [];
    
    for (let i = 0; i < algorithms.length; i++) {
      const algorithm = algorithms[i];
      const password = passwords[i] || passwords[0];
      
      const result = await this.encryptAES(currentText, password, algorithm);
      
      if (!result.success) {
        return result;
      }
      
      layers.push({
        layer: i + 1,
        algorithm: algorithm,
        result: result.encrypted
      });
      
      currentText = result.encrypted;
    }
    
    return {
      success: true,
      encrypted: currentText,
      layers: layers.length,
      algorithms: algorithms,
      note: 'Decrypt in reverse order with corresponding passwords'
    };
  }
}

// Usage examples
const encryption = new TextEncryption();

// AES Encryption
console.log('AES Encryption:');
const plaintext = 'This is my secret message!';
const password = 'myStrongPassword123';
const encrypted = await encryption.encryptAES(plaintext, password, 'AES-256-GCM');
console.log(encrypted);

// AES Decryption
if (encrypted.success) {
  console.log('\nAES Decryption:');
  const decrypted = await encryption.decryptAES(encrypted.encrypted, password, 'AES-256-GCM');
  console.log(decrypted);
}

// RSA Key Generation
console.log('\nRSA Key Generation:');
const keyPair = await encryption.generateRSAKeyPair(2048);
console.log(keyPair);

// Simple ciphers
console.log('\nSimple Ciphers:');
console.log('Caesar:', encryption.encryptCaesar('Hello World', 5));
console.log('ROT13:', encryption.rot13('Hello World'));
console.log('Base64:', encryption.base64Encode('Hello World'));

console.log('Encryption tools ready!');