Generador de Contraseñas

Un generador de contraseñas crea contraseñas aleatorias y difíciles de adivinar según longitud y reglas de caracteres elegidas. Un buen generador usa aleatoriedad criptográficamente segura y combina mayúsculas, minúsculas, números y símbolos solo cuando el sistema de destino los acepta. Las contraseñas fuertes reducen ataques de diccionario, fuerza bruta y credential stuffing, pero no sustituyen hábitos como usar un gestor, mantener una contraseña distinta por cuenta y activar autenticación multifactor. Las contraseñas muy complejas no deberían memorizarse ni reutilizarse; deben almacenarse de forma segura. En sistemas compartidos también importan rotación, propiedad y reglas de acceso.

El generador de contraseñas obtiene aleatoriedad de crypto.getRandomValues(new Uint32Array(n)), que rellena un array tipado con valores pseudoaleatorios criptográficamente seguros provenientes del pool de entropía del sistema operativo (getrandom en Linux, BCryptGenRandom en Windows, SecRandomCopyBytes en macOS/iOS). Se trata de un CSPRNG según lo definido por la W3C Web Cryptography API, a diferencia de Math.random(), que en V8 utiliza el algoritmo xorshift128+ y está explícitamente documentado como no criptográfico y predecible a partir de una pequeña muestra de salidas. El conjunto de caracteres se ensambla a partir de las clases seleccionadas por el usuario: mayúsculas (26 letras A-Z), minúsculas (26 letras a-z), dígitos (10 caracteres 0-9) y símbolos (32 caracteres de !@#$%^&*()_+-=[]{}|;:,.<>?), lo que da un pool máximo de 94 caracteres. Un conjunto personalizado o una lista de exclusión (incluyendo un filtro de caracteres ambiguos que elimina i, I, l, L, 1, o, O, 0) refina aún más el pool. Cada carácter de la contraseña se selecciona tomando array[i] % pool.length, distribución uniforme porque la salida del CSPRNG es uniforme sobre 32 bits y el sesgo de módulo (|pool| no divide 2^32 exactamente) es despreciable para pools de menos de 256 caracteres: el sesgo es inferior al 0.00000006%, muy por debajo de cualquier preocupación práctica. La fortaleza de la contraseña se mide por el tamaño del espacio de búsqueda: para un pool de tamaño C y longitud L, el número de contraseñas posibles es C^L. La entropía en bits es log2(C^L) = L x log2(C). Para una contraseña de 16 caracteres con las cuatro clases habilitadas (C=94), esto produce 94^16 ≈ 4.4 x 10^31 combinaciones, o unos 105 bits de entropía. A una tasa hipotética de 10^12 intentos por segundo (aproximadamente el rendimiento de un gran clúster de GPU contra un hash rápido como NTLM), la búsqueda exhaustiva tomaría aproximadamente 4.4 x 10^19 segundos, mucho más que la edad del universo. Este modelo asume que el atacante debe probar cada combinación (sin atajos de diccionario o basados en patrones) y que la contraseña se hashea con un algoritmo lento y con sal como bcrypt o Argon2id en lugar de almacenarse en texto plano. NIST SP 800-63B recomienda un mínimo de 8 caracteres para contraseñas elegidas por el usuario y al menos 6 caracteres generados aleatoriamente para credenciales generadas por máquina, con el conjunto de caracteres documentado. El rango de longitud del generador de 4 a 64 caracteres cubre desde códigos PIN hasta credenciales de máquina de alta entropía. La opción de empezar con letra asegura que el primer carácter se elige de [A-Za-z], lo que satisface sistemas heredados que requieren que las contraseñas comiencen con una letra.

• Fuente CSPRNG: crypto.getRandomValues() obtiene entropía del CSPRNG del núcleo del SO (getrandom/BCryptGenRandom/SecRandomCopyBytes), a diferencia de Math.random() (xorshift128+), no es predecible, no se puede sembrar desde la página y es adecuado para generación de credenciales.
• Matemáticas del espacio de caracteres: con las cuatro clases habilitadas, el tamaño del pool es 94; la entropía por carácter es log2(94) ≈ 6.55 bits. Una contraseña de 16 caracteres tiene ~105 bits de entropía; duplicar la longitud a 32 eleva esto a ~210 bits.
• Selección por módulo: array[i] % pool.length mapea la salida de 32 bits del CSPRNG a un índice de carácter; el sesgo es inferior al 6 x 10^-8 % para pools de menos de 256 caracteres, lo que lo hace criptográficamente irrelevante.
• Modelo de resistencia a fuerza bruta: a 10^12 intentos/segundo (escala de clúster de GPU), una contraseña de 16 caracteres con 94 símbolos tomaría ~10^19 segundos para agotarse, pero esto asume un hash rápido; bcrypt con factor de costo 12 reduce al atacante a ~10^4 intentos/segundo, haciendo que incluso contraseñas de 8 caracteres sean resilientes.
• Exclusión de caracteres ambiguos: el filtro elimina {i, I, l, L, 1, o, O, 0} (8 caracteres), lo que reduce el pool de 94 a 86, costando aproximadamente 0.6 bits de entropía por carácter, aceptable por la ganancia en usabilidad en escenarios de transcripción manual.
• Alineación con NIST SP 800-63B: el estándar requiere un mínimo de 6 caracteres elegidos aleatoriamente para secretos generados por máquina y recomienda documentar el espacio de caracteres; los preajustes del generador (Simple 8 caracteres, Fuerte 20 caracteres) se asignan a diferentes niveles de garantía.
• Historial en localStorage: las últimas 10 contraseñas generadas se persisten en window.localStorage, que está acotado al origen y perfil del navegador; borrar el historial las elimina del almacenamiento, pero una herramienta forense a nivel de disco podría recuperarlas porque localStorage se almacena como una base de datos SQLite en texto plano en el directorio del perfil del navegador.