Generador de Contraseñas

¿Qué es un generador de contraseñas?

Un generador de contraseñas crea cadenas de caracteres aleatorias usadas como contraseñas para cuentas de usuario, API keys, credenciales de base de datos y secretos de cifrado. A diferencia de las contraseñas elegidas por personas, las contraseñas generadas toman del espacio completo de combinaciones de caracteres posibles, lo que las hace resistentes a ataques de diccionario y adivinanzas basadas en patrones. Esta herramienta genera contraseñas aleatorias y seguras en línea usando el generador de números aleatorios criptográfico integrado en tu navegador.

La fortaleza de una contraseña depende de dos factores: longitud y diversidad de caracteres. Una contraseña de 20 caracteres que usa mayúsculas, minúsculas, dígitos y símbolos tiene aproximadamente 131 bits de entropía. A ese nivel, un ataque de fuerza bruta que pruebe un billón de intentos por segundo necesitaría más tiempo que la edad del universo para probar cada combinación. La matemática es directa: entropía = longitud x log2(tamaño del conjunto de caracteres).

Estándares como NIST SP 800-63B recomiendan contraseñas de al menos 8 caracteres sin límite superior impuesto por el verificador, y desaconsejan reglas de composición forzadas como exigir exactamente un símbolo, favoreciendo en cambio frases más largas. Para credenciales máquina-a-máquina y cuentas de servicio, 20 o más caracteres aleatorios tomados de un conjunto completo de caracteres es la línea base aceptada en la mayoría de marcos de seguridad y regímenes de cumplimiento.

¿Por qué usar un generador de contraseñas?

Las personas somos malos generadores de números aleatorios. Reutilizamos contraseñas, elegimos palabras del diccionario, sustituimos letras con patrones predecibles (@ por a, 3 por e) y recurrimos a cadenas cortas. Un generador de contraseñas elimina el sesgo humano del proceso.

Casos de uso del generador de contraseñas

Referencia de entropía de contraseñas

La entropía mide qué tan impredecible es una contraseña. Se calcula como log2(tamaño_conjunto ^ longitud). Mayor entropía significa más combinaciones posibles que un atacante debe recorrer. NIST y OWASP recomiendan al menos 80 bits de entropía para aplicaciones de alta seguridad.

Los tiempos de descifrado asumen 1 billón de intentos por segundo (ataque offline con GPUs modernas). Los ataques en línea con limitación de velocidad son órdenes de magnitud más lentos.

CSPRNG vs Math.random() para generar contraseñas

La fuente de aleatoriedad importa tanto como la longitud de la contraseña. Una contraseña generada con un generador de números aleatorios predecible puede ser reconstruida por un atacante que conozca el algoritmo y el estado de la semilla. Esta herramienta usa crypto.getRandomValues(), que es un generador de números pseudoaleatorios criptográficamente seguro (CSPRNG) incorporado en todos los navegadores modernos.

Ejemplos de código

Genera contraseñas de forma programática en diferentes lenguajes. Cada ejemplo a continuación usa una fuente aleatoria criptográficamente segura, no Math.random() ni PRNGs débiles equivalentes.

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

import (
    "crypto/rand"
    "fmt"
    "math/big"
)

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

Preguntas frecuentes