Generador de Contraseñas Seguras: Crea Passphrases y Passwords Fuertes

13 de septiembre de 2026·Equipo Solvya·3 min de lectura

Genera contraseñas aleatorias criptográficamente seguras (entropía real) y passphrases memorables (Diceware/EFF). Personaliza longitud, juego de caracteres, excluye ambiguos. Todo client-side, cero logs.

ℹ️ Este contenido es educativo e informativo. No constituye asesoramiento profesional. Consulta con un especialista antes de tomar decisiones.

La entropía (aleatoriedad real) es lo que hace una contraseña inquebrantable. Nuestro generador de contraseñas seguras usa crypto.getRandomValues() (Web Crypto API) — el CSPRNG nativo del navegador — para crear passwords y passphrases con entropía medible en bits, sin Math.random(), 100 % en tu dispositivo.

Dos modos: Password vs Passphrase

Modo	Formato	Entropía típica	Mejor para
Password	`xK9#mP2$vL5@`	80–128 bits (16–24 chars)	Cuentas web, apps, bases de datos, API keys
Passphrase	`correct-horse-battery-staple`	52–90 bits (4–7 palabras)	Master password (Bitwarden, 1Password), cifrado disco (VeraCrypt, LUKS, FileVault), clave GPG/SSH passphrase

Regla de oro: usa passphrase para la llave maestra que desbloquea todo lo demás. Usa passwords aleatorias únicas (guardadas en gestor) para cada servicio.

Entropía: bits, no “fuerza visual”

La “fuerza” que muestran medidores de barras es teatro de seguridad. Lo que importa son bits de entropía:

Entropía (bits)	Resistencia a	Ejemplo
< 40	Trivial (segundos)	`password123`
40–50	Horas/días (online)	`Verano2024!`
50–60	Meses (online)	Passphrase 3 palabras
60–70	Años (online, rate-limited)	Password 14 chars alfanumérico
70–80	Siglos (online) / días (offline GPU)	Passphrase 4 palabras Diceware
80–100	Inquebrantable offline (GPU cluster)	Password 20 chars / Passphrase 5 palabras
100–128	Secreto a largo plazo (claves raíz, seeds)	Passphrase 7 palabras / Password 24+ chars

Nuestro generador muestra los bits exactos y el tiempo estimado de crack (online @ 1M/s, offline @ 100B/s GPU).

Listas de palabras para passphrases

Lista	Palabras	Entropía/palabra	Uso recomendado
EFF Long (Diceware)	7.776	12.9 bits	Master password, cifrado, GPG
EFF Short	1.296	10.3 bits	Passphrases más cortas, legibles
BIP-39 (English)	2.048	11 bits	Seed phrases crypto (12/24 palabras)
Diceware original	7.776	12.9 bits	Clásico, compatible

Separadores: - (guion), _ (underscore), (espacio), . (punto). El guion es el estándar Diceware.

Checklist de higiene de contraseñas

Única por servicio: nunca reutilices (credential stuffing).
Generada aleatoriamente: nada de patrones, fechas, nombres, sustituciones (@→a).
Guardada en gestor: Bitwarden (open source), 1Password, KeePassXC, Proton Pass, Vaultwarden (self-host).
2FA activado: TOTP (Authy, Aegis, Bitwarden) > SMS > email. Claves de acceso (Passkeys) donde esté disponible.
Master passphrase fuerte: ≥ 80 bits (5 palabras EFF Long + separador).
Revisión periódica: exporta vault → haveibeenpwned.com (o función integrada del gestor).

Qué NO hacer

❌ Mal	✅ Bien
`Verano2024!` en 10 sitios	Passphrase única 5 palabras para master; passwords aleatorias 18+ chars para cada sitio (en gestor)
Guardar en Excel/Notas/Google Docs	Gestor de contraseñas cifrado (zero-knowledge)
Compartir por WhatsApp/email	Compartir via vault sharing (Bitwarden Organizations, 1Password Families)
Cambiar cada 90 días (política antigua)	Cambiar solo si hay brecha (NIST 800-63B). Longitud + aleatoriedad > rotación forzada.

Privacidad total: client-side only

CSPRNG: crypto.getRandomValues(new Uint32Array(n)) — entropía del SO (RDRAND, getrandom, /dev/urandom).
Cero red: la página es estática (Astro), el JS corre en tu navegador. Abre la herramienta, desconecta WiFi, sigue generando.
Cero almacenamiento: no localStorage, no sessionStorage, no IndexedDB, no cookies.
Cero analytics: ni GA, ni Plausible, ni Matomo en la herramienta.

Generar contraseña segura ahora.

Referencias técnicas

NIST SP 800-63B (Digital Identity Guidelines): longitud ≥ 8, sin reglas de composición, screening contra brechas, sin rotación forzada.
Diceware / EFF wordlists: 7.776 palabras, 12.9 bits/palabra.
BIP-39: 2.048 palabras, 11 bits/palabra, checksum integrado.
zxcvbn (Dropbox): estimador realista de entropía (usado internamente para mostrar bits).

¿Necesitas una contraseña fuerte ya? → Abrir generador y obtén una en 1 click (client-side, cero logs).

Entropy (true randomness) is what makes a password unbreakable. Our secure password generator uses crypto.getRandomValues() (Web Crypto API) — the browser-native CSPRNG — to create passwords and passphrases with measurable entropy in bits, no Math.random(), 100 % on your device.

Two modes: Password vs Passphrase

Mode	Format	Typical entropy	Best for
Password	`xK9#mP2$vL5@`	80–128 bits (16–24 chars)	Web accounts, apps, databases, API keys
Passphrase	`correct-horse-battery-staple`	52–90 bits (4–7 words)	Master password (Bitwarden, 1Password), disk encryption (VeraCrypt, LUKS, FileVault), GPG/SSH passphrase

Golden rule: use passphrase for the master key that unlocks everything else. Use unique random passwords (stored in manager) for each service.

Entropy: bits, not “visual strength”

The “strength” shown by bar meters is security theater. What matters is bits of entropy:

Entropy (bits)	Resistance to	Example
< 40	Trivial (seconds)	`password123`
40–50	Hours/days (online)	`Summer2024!`
50–60	Months (online)	Passphrase 3 words
60–70	Years (online, rate-limited)	Password 14 alphanumeric chars
70–80	Centuries (online) / days (offline GPU)	Passphrase 4 Diceware words
80–100	Unbreakable offline (GPU cluster)	Password 20 chars / Passphrase 5 words
100–128	Long-term secrets (root keys, seeds)	Passphrase 7 words / Password 24+ chars

Our generator shows exact bits and estimated crack time (online @ 1M/s, offline @ 100B/s GPU).

Wordlists for passphrases

List	Words	Entropy/word	Recommended use
EFF Long (Diceware)	7,776	12.9 bits	Master password, encryption, GPG
EFF Short	1,296	10.3 bits	Shorter, readable passphrases
BIP-39 (English)	2,048	11 bits	Crypto seed phrases (12/24 words)
Diceware original	7,776	12.9 bits	Classic, compatible

Separators: - (hyphen), _ (underscore), (space), . (dot). Hyphen is the Diceware standard.

Password hygiene checklist

Unique per service: never reuse (credential stuffing).
Randomly generated: no patterns, dates, names, substitutions (@→a).
Stored in manager: Bitwarden (open source), 1Password, KeePassXC, Proton Pass, Vaultwarden (self-host).
2FA enabled: TOTP (Authy, Aegis, Bitwarden) > SMS > email. Passkeys where available.
Strong master passphrase: ≥ 80 bits (5 EFF Long words + separator).
Periodic review: export vault → haveibeenpwned.com (or manager’s built-in feature).

What NOT to do

❌ Bad	✅ Good
`Summer2024!` on 10 sites	Unique 5-word passphrase for master; random 18+ char passwords for each site (in manager)
Store in Excel/Notes/Google Docs	Encrypted password manager (zero-knowledge)
Share via WhatsApp/email	Share via vault sharing (Bitwarden Organizations, 1Password Families)
Rotate every 90 days (old policy)	Change only if breached (NIST 800-63B). Length + randomness > forced rotation.

Total privacy: client-side only

CSPRNG: crypto.getRandomValues(new Uint32Array(n)) — OS entropy (RDRAND, getrandom, /dev/urandom).
Zero network: page is static (Astro), JS runs in your browser. Open tool, disconnect WiFi, keep generating.
Zero storage: no localStorage, no sessionStorage, no IndexedDB, no cookies.
Zero analytics: no GA, no Plausible, no Matomo on the tool.

Generate secure password now.

Technical references

NIST SP 800-63B (Digital Identity Guidelines): length ≥ 8, no composition rules, breach screening, no forced rotation.
Diceware / EFF wordlists: 7,776 words, 12.9 bits/word.
BIP-39: 2,048 words, 11 bits/word, built-in checksum.
zxcvbn (Dropbox): realistic entropy estimator (used internally to show bits).

Need a strong password now? → Open generator and get one in 1 click (client-side, zero logs).

Preguntas frecuentes

¿Es seguro generar contraseñas en el navegador?

Sí. Usamos `crypto.getRandomValues()` (Web Crypto API) — **CSPRNG nativo del navegador**. No usamos `Math.random()`. La generación es 100 % client-side: nada sale de tu dispositivo, no hay logs, no hay red.

¿Qué es una passphrase y por qué es mejor que una contraseña aleatoria?

Una **passphrase** son 4–7 palabras aleatorias de una lista estándar (Diceware/EFF). Ej: `correct-horse-battery-staple`. Tiene **entropía alta** (≈ 52 bits para 4 palabras) y **es memorable**. Ideal para master password de gestor de contraseñas, cifrado de disco (VeraCrypt/LUKS) o clave maestra.

¿Cuánta entropía necesito?

**≥ 60 bits** para cuentas online (rata de 10⁶ intentos/s online). **≥ 80 bits** para claves maestras / cifrado offline (rata 10¹² intentos/s GPU). **128 bits** para secreto a largo plazo (claves SSH, GPG, seed wallets). El generador muestra la entropía exacta en bits.

¿Debo excluir caracteres ambiguos (l, 1, I, O, 0)?

Sí, si vas a **copiar a mano** o dictar. Reduce entropía marginalmente (≈ 0.5 bits/char) pero evita errores de transcripción. Para gestor de contraseñas (copiar-pegar), déjalos: más entropía por carácter.

¿Puedo usar esto para claves SSH, GPG o seed phrases de crypto?

Para **SSH/GPG**: usa `ssh-keygen` o `gpg --gen-key` (generan claves asimétricas, no passwords). Para **seed phrases (BIP-39)**: usa el generador de passphrase con **12/24 palabras de la lista BIP-39** (no Diceware/EFF). Este generador es para **passwords/passphrases simétricas**.

Is it safe to generate passwords in the browser?

Yes. We use `crypto.getRandomValues()` (Web Crypto API) — **browser-native CSPRNG**. No `Math.random()`. Generation is 100 % client-side: nothing leaves your device, no logs, no network.

What is a passphrase and why is it better than a random password?

A **passphrase** is 4–7 random words from a standard list (Diceware/EFF). Example: `correct-horse-battery-staple`. It has **high entropy** (~52 bits for 4 words) and **is memorable**. Ideal for password manager master password, disk encryption (VeraCrypt/LUKS) or master key.

How much entropy do I need?

**≥ 60 bits** for online accounts (10⁶ guesses/s online). **≥ 80 bits** for master keys / offline encryption (10¹² guesses/s GPU). **128 bits** for long-term secrets (SSH keys, GPG, wallet seeds). The generator shows exact entropy in bits.

Should I exclude ambiguous characters (l, 1, I, O, 0)?

Yes, if you'll **copy by hand** or dictate. Reduces entropy marginally (~0.5 bits/char) but avoids transcription errors. For password manager (copy-paste), keep them: more entropy per char.

Can I use this for SSH keys, GPG or crypto seed phrases?

For **SSH/GPG**: use `ssh-keygen` or `gpg --gen-key` (they generate asymmetric keys, not passwords). For **seed phrases (BIP-39)**: use passphrase generator with **12/24 words from BIP-39 list** (not Diceware/EFF). This generator is for **symmetric passwords/passphrases**.