2FA Authentication Code Generator

/**
 * Generates a TOTP code based on the provided parameters
 * @param {string} secret - Base32 encoded secret key
 * @param {number} period - Time step in seconds (default: 30)
 * @param {number} digits - Number of digits in the code (default: 6)
 * @param {string} algorithm - Hash algorithm to use (default: 'SHA-1')
 * @returns {string} - The generated TOTP code
 */
async function generateTOTP(secret, period = 30, digits = 6, algorithm = 'SHA-1') {
  // Decode the base32 secret
  const key = decodeBase32(secret);
  
  // Calculate the counter value (number of time steps since Unix epoch)
  const counter = Math.floor(Date.now() / 1000 / period);
  
  // Convert counter to buffer
  const counterBuffer = new ArrayBuffer(8);
  const counterView = new DataView(counterBuffer);
  
  // Set counter value as big-endian
  counterView.setBigUint64(0, BigInt(counter), false);
  
  // Generate HMAC
  const cryptoAlgo = algorithm.replace('-', '');
  const hmacKey = await crypto.subtle.importKey(
    'raw', key, { name: 'HMAC', hash: { name: cryptoAlgo } },
    false, ['sign']
  );
  
  const hmac = await crypto.subtle.sign(
    'HMAC', hmacKey, counterBuffer
  );
  
  // Dynamic truncation
  const hmacArray = new Uint8Array(hmac);
  const offset = hmacArray[hmacArray.length - 1] & 0xf;
  
  // Get 4-byte truncated value
  const truncatedView = new DataView(hmac);
  let code = truncatedView.getUint32(offset, false) & 0x7fffffff;
  
  // Generate code with specified number of digits
  code = code % Math.pow(10, digits);
  
  // Pad with leading zeros if necessary
  return code.toString().padStart(digits, '0');
}

/**
 * Decodes a base32 string to a Uint8Array
 * @param {string} base32 - Base32 encoded string
 * @returns {Uint8Array} - Decoded bytes
 */
function decodeBase32(base32) {
  // Base32 character set (RFC 4648)
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
  const padding = '=';
  
  // Remove padding and convert to uppercase
  let str = base32.toUpperCase().replace(/=/g, '');
  
  // Calculate output length
  const byteCount = Math.floor((str.length * 5) / 8);
  const result = new Uint8Array(byteCount);
  
  let bits = 0;
  let value = 0;
  let index = 0;
  
  for (let i = 0; i < str.length; i++) {
    const c = str.charAt(i);
    const charIndex = charset.indexOf(c);
    
    if (charIndex === -1) {
      throw new Error('Invalid character in base32 string');
    }
    
    // Add 5 bits to the buffer
    value = (value << 5) | charIndex;
    bits += 5;
    
    // If we have at least 8 bits, write a byte
    if (bits >= 8) {
      bits -= 8;
      result[index++] = (value >> bits) & 0xff;
    }
  }
  
  return result;
}