AI Password Generator Chrome Extension: A Developer Guide

// password-generator.js
class AIPasswordGenerator {
  constructor(options = {}) {
    this.length = options.length || 16;
    this.includeSymbols = options.includeSymbols ?? true;
    this.includeNumbers = options.includeNumbers ?? true;
    this.useMemorable = options.useMemorable ?? false;
    this.context = options.context || '';
  }

  // Generate using AI-style pattern recognition
  async generate() {
    if (this.useMemorable) {
      return this.generateMemorable();
    }
    return this.generateSecure();
  }

  generateSecure() {
    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
    const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    const numbers = '0123456789';
    const symbols = '!@#$%^&*()_+-=[]{}|;:,.<>?';

    let charset = lowercase + uppercase;
    if (this.includeNumbers) charset += numbers;
    if (this.includeSymbols) charset += symbols;

    // Use crypto.getRandomValues for cryptographically secure randomness
    const randomValues = new Uint32Array(this.length);
    crypto.getRandomValues(randomValues);

    let password = '';
    for (let i = 0; i < this.length; i++) {
      password += charset[randomValues[i] % charset.length];
    }

    // Ensure password meets complexity requirements
    return this.enforceComplexity(password);
  }

  generateMemorable() {
    // Generate password using pronounceable pattern
    const consonants = 'bcdfghjklmnpqrstvwxyz';
    const vowels = 'aeiou';
    
    let password = '';
    const randomValues = new Uint32Array(this.length);
    crypto.getRandomValues(randomValues);

    for (let i = 0; i < this.length; i++) {
      if (i % 2 === 0) {
        password += consonants[randomValues[i] % consonants.length];
      } else {
        password += vowels[randomValues[i] % vowels.length];
      }
    }

    // Inject numbers and symbols at random positions
    return this.injectSpecialChars(password);
  }

  injectSpecialChars(password) {
    const numbers = '0123456789';
    const symbols = '!@#$%';
    const randomValues = new Uint32Array(2);
    crypto.getRandomValues(randomValues);

    const numPos = randomValues[0] % password.length;
    const symPos = randomValues[1] % password.length;

    const chars = password.split('');
    chars[numPos] = numbers[randomValues[0] % numbers.length];
    if (symPos !== numPos) {
      chars[symPos] = symbols[randomValues[1] % symbols.length];
    }

    return chars.join('');
  }

  enforceComplexity(password) {
    // Ensure at least one character from each required set
    const hasLower = /[a-z]/.test(password);
    const hasUpper = /[A-Z]/.test(password);
    const hasNumber = /[0-9]/.test(password);
    const hasSymbol = /[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/.test(password);

    if (!hasLower || !hasUpper || !hasNumber || !hasSymbol) {
      return this.generateSecure(); // Regenerate if complexity fails
    }
    return password;
  }

  // Calculate entropy for security scoring
  calculateEntropy(password) {
    let charsetSize = 0;
    if (/[a-z]/.test(password)) charsetSize += 26;
    if (/[A-Z]/.test(password)) charsetSize += 26;
    if (/[0-9]/.test(password)) charsetSize += 10;
    if (/[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/.test(password)) charsetSize += 32;

    const entropy = password.length * Math.log2(charsetSize);
    return Math.round(entropy);
  }
}

// popup.js
document.addEventListener('DOMContentLoaded', () => {
  const output = document.getElementById('output');
  const strengthEl = document.getElementById('strength');
  
  const generator = new AIPasswordGenerator();

  document.getElementById('generate').addEventListener('click', () => {
    const options = {
      length: parseInt(document.getElementById('length').value),
      includeSymbols: document.getElementById('includeSymbols').checked,
      includeNumbers: document.getElementById('includeNumbers').checked,
      useMemorable: document.getElementById('useMemorable').checked
    };

    const password = new AIPasswordGenerator(options).generate();
    const entropy = new AIPasswordGenerator(options).calculateEntropy(password);
    
    output.textContent = password;
    displayStrength(entropy);
    
    // Store for clipboard copy
    output.dataset.password = password;
  });

  function displayStrength(entropy) {
    let text, className;
    if (entropy >= 60) {
      text = `Strong (${entropy} bits entropy)`;
      className = 'strong';
    } else if (entropy >= 40) {
      text = `Medium (${entropy} bits entropy)`;
      className = 'medium';
    } else {
      text = `Weak (${entropy} bits entropy)`;
      className = 'weak';
    }
    strengthEl.textContent = text;
    strengthEl.className = 'strength ' + className;
  }

  document.getElementById('copy').addEventListener('click', () => {
    const password = output.dataset.password;
    if (password) {
      navigator.clipboard.writeText(password).then(() => {
        const btn = document.getElementById('copy');
        btn.textContent = 'Copied!';
        setTimeout(() => btn.textContent = 'Copy to Clipboard', 1500);
      });
    }
  });

  // Generate initial password
  document.getElementById('generate').click();
});

// Clear clipboard after 30 seconds for security
setTimeout(() => {
  navigator.clipboard.writeText('');
}, 30000);