# Generador de Contraseñas

> Una página de jmrp.io, publicada como markdown. Índice: https://jmrp.io/llms.txt

Canonical: https://jmrp.io/es/tools/password-generator/
Language: es
Alternate: https://jmrp.io/tools/password-generator/index.md
Updated: 2026-09-03
License: https://jmrp.io/es/license/
Category: security
Tags: contraseña, seguridad, crypto, passphrase, entropía

Genera contraseñas y frases de contraseña seguras con la Web Crypto API. Estima entropía y tiempo de descifrado. Todo en el navegador.
Build-Date: 2026-09-06

Características:
- Web Crypto API con muestreo por rechazo
- Modos de contraseña y frase Diceware
- Entropía y tiempo de crackeo en tiempo real
- Longitud, conjuntos y separadores personalizables
- Excluye caracteres ambiguos, todo en el navegador

Preguntas que responde:

**¿Es seguro generar contraseñas en un navegador web?**

Sí. Este generador funciona completamente en el lado del cliente usando la Web Crypto API del navegador (crypto.getRandomValues), por lo que las contraseñas nunca se transmiten, almacenan ni registran. Nada sale de tu dispositivo.

**¿Qué es la entropía de una contraseña y cuántos bits necesito?**

La entropía mide la imprevisibilidad en bits — cada bit duplica el número de intentos necesarios para descifrar la contraseña. Apunta a al menos 80 bits para cuentas importantes y 100+ bits para secretos de alto valor.

**¿Son las frases de contraseña más seguras que las contraseñas aleatorias?**

Una frase de contraseña puede igualar o superar a una contraseña aleatoria si tiene suficientes palabras. Cada palabra aleatoria de una lista grande añade unos 12-13 bits de entropía, así que una frase estilo Diceware de 5-6 palabras es fuerte y más fácil de recordar.

**¿Por qué debería excluir caracteres ambiguos como 0, O, l, 1 e I?**

Excluir caracteres visualmente similares evita errores de transcripción al leer o teclear una contraseña manualmente. Reduce ligeramente el conjunto de caracteres, así que añade algo de longitud para mantener la misma entropía.

**¿Basta el tiempo de descifrado para saber si mi contraseña es fuerte?**

No por sí solo. La estimación de tiempo de descifrado supone fuerza bruta a 1 billón de intentos por segundo, pero los ataques reales explotan la reutilización, las filtraciones y los patrones de diccionario. Usa una contraseña única y de alta entropía por cuenta y un gestor de contraseñas.


---

**Herramienta interactiva** — esta página contiene la aplicación en funcionamiento, no una descripción de ella.

## Acerca de esta herramienta

Genera contraseñas fuertes y aleatorias usando el generador de números aleatorios criptográficos del navegador (`crypto.getRandomValues`). Elige entre contraseñas basadas en caracteres y frases de contraseña estilo Diceware para la máxima seguridad. El muestreo por rechazo elimina el sesgo modular para una aleatoriedad uniforme.

### Características

- **Aleatoriedad criptográficamente segura** — usa la Web Crypto API con muestreo por rechazo
- **Modos de contraseña y frase de contraseña** — basado en caracteres o en palabras
- **Estimación de entropía** — bits de entropía calculados en tiempo real
- **Estimación de tiempo de descifrado** — cuánto tardaría un ataque de fuerza bruta a 1 billón de intentos/seg
- **Excluir caracteres ambiguos** — elimina 0, O, l, 1, I para evitar confusión
- **Personalizable** — longitud, conjuntos de caracteres, separadores de palabras, mayúsculas, añadir número

### ¿Cómo se usa?

1. Elige entre el modo Contraseña aleatoria o Frase de contraseña
2. Ajusta la longitud y los conjuntos de caracteres (o cantidad de palabras/separador)
3. Opcionalmente excluye caracteres ambiguos
4. Usa el botón de recarga («Generar nueva contraseña») para obtener otra, o
  el de copiar («Copiar contraseña») para llevarla al portapapeles

### ¿Es privado?

Toda la generación de contraseñas ocurre completamente en tu navegador usando
la Web Crypto API. No se transmite, almacena ni registra ninguna contraseña.
Las contraseñas generadas nunca salen de tu dispositivo.

### Referencia de comandos Linux

Puedes generar contraseñas desde la terminal usando herramientas integradas
de Linux. Estos son los métodos más comunes:

#### Contraseña aleatoria (conjunto mixto)

```bash
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
```

**Salida — Contraseña generada**

```text
2!P1n4guiZoDakfl^$kb
```

#### Solo alfanumérica

```bash
tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 20; echo
```

**Salida — Contraseña alfanumérica**

```text
A0efMcTih9nrMk00jwcC
```

#### Usando OpenSSL

```bash
# Codificación Base64 (32 caracteres)
openssl rand -base64 24

# Hexadecimal (32 caracteres)
openssl rand -hex 16
```

**Salida — Contraseñas con OpenSSL**

```text
1M6FfJr6NlDSLw9gv778Vij+TQ71K4Wq
190c2dfbaa87d6913dceb851da074529
```

#### Generación por lotes

```bash
for i in $(seq 1 5); do
  tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 16
  echo
done
```

**Salida — Contraseñas por lotes**

```text
KOPzWKzFRxELibkql
g5ZcvgkwkjP5NRVq
bKCBZjFF3KpiiQNM
n4k6G9OCpJAPfwpR
900Qx98a5lsM9KoN
```

#### Frase de contraseña (estilo Diceware)

```bash
# Elegir 5 palabras aleatorias del diccionario del sistema
grep -E '^[a-z]{4,8}$' /usr/share/dict/words | shuf -n 5 | paste -sd '-'
```

**Salida — Frase de contraseña generada**

```text
coiling-hurdled-splodge-whatever-evoking
```

#### Usando pwgen

`pwgen` es un generador de contraseñas dedicado disponible en la mayoría de distribuciones (`sudo apt install pwgen`). Soporta modos pronunciables y completamente aleatorios.

```bash
# Aleatorio seguro, 20 caracteres
pwgen -s 20 1

# Con símbolos
pwgen -sy 20 1

# Sin caracteres ambiguos (0O l1I)
pwgen -sB 20 1

# Pronunciable (más fácil de recordar)
pwgen 16 1
```

**Salida — Contraseñas con pwgen**

```text
SHbLIPZyUV14zD8A3oy5
^JVR/.gSlO7Oqx;I%lCx
ipWxHLHUUnfYohXxj4PV
jeigiejeif4dooKa
```

```bash
# Lote: 5 contraseñas seguras con símbolos
pwgen -sy1 16 5
```

**Salida — Contraseñas pwgen por lotes**

```text
8sQjvZe|wCt5x#10
ZVFFnjMxP]4]oAv
c[-c9c7jutE~DMC9
xgVO3RMb=qbw7dK
C4ym_QneYiM|jrVW
```

#### Cálculo de entropía

```bash
python3 -c "
import math
pool = 26+26+10+8  # A-Z, a-z, 0-9, símbolos
length = 20
entropy = math.log2(pool) * length
years = (2**entropy / 1e12) / 31557600
print(f'Pool: {pool} chars')
print(f'Entropy: {entropy:.1f} bits')
print(f'Crack time (1T/s): {years:.2e} years')
"
```

**Salida — Análisis de entropía**

```text
Pool: 70 chars
Entropy: 122.6 bits
Crack time (1T/s): 2.53e+17 years
```