Generador y Validador de Contraseñas

Genera contraseñas fuertes y frases de contraseña, con soporte para validación por lotes, unicidad, intensidad y políticas, además de ejemplos de código en múltiples idiomas y conocimientos prácticos.

Probador de políticas de contraseña

Contraseña a probar

Longitud mínima Requerir letras minúsculas Requerir letras mayúsculas Requerir dígitos Requerir símbolos Prohibir secuencias consecutivas (por ejemplo, abc, 123) Prohibir repeticiones largas (por ejemplo, aaaa)

Resultados

Longitud
Minúsculas
Mayúsculas
Dígitos
Símbolos
Secuencias consecutivas
Repeticiones
Lista negra

Todas las validaciones se realizan localmente en tu navegador.

Generador de frases de contraseña

Número de palabras

Separador

Primera letra en mayúscula Agregar número

Las palabras se seleccionan mediante generación aleatoria segura (Web Crypto). La lista de palabras de demostración es limitada por restricciones de tamaño.

Tabla de referencia para hash de contraseñas

Argon2id

Use Argon2id con parámetros de memoria ajustados adecuadamente
Iteraciones ≥ 2, memoria ≥ 64 MB (ajustar según el entorno)
Almacene una sal independiente por usuario; opcionalmente use un pepper a nivel de aplicación

PBKDF2

Elija SHA-256 o SHA-512 con iteraciones ≥ 210k (ajustar según necesidad)
Use una sal única por hash; soporte para actualización de parámetros
Migre a parámetros de mayor costo en el próximo inicio de sesión del usuario

BCrypt

Costo entre 10 y 14, dependiendo de la capacidad del servidor
Evite truncamientos; realice el hash sobre la contraseña completa
Implemente limitación de tasa y monitoreo en los puntos de autenticación

Referencia: NIST SP 800-63B, OWASP ASVS. Los parámetros deben adaptarse a la capacidad del hardware y los SLO.

Evaluación de la fortaleza de la contraseña

La fortaleza se estima a partir de la entropía: entropy = log2(tamaño del conjunto de caracteres) × longitud. Un conjunto de caracteres más grande y una longitud mayor mejoran la resistencia a los intentos de adivinación.

Débil: < 50 bits —— Solo adecuado para escenarios temporales o de bajo valor
Regular: 50–80 bits —— Aceptable para escenarios de bajo riesgo
Fuerte: 80–110 bits —— Objetivo recomendado por defecto
Excelente: > 110 bits —— Recomendado para cuentas de administrador o críticas

Nota: Los modelos de ataque reales pueden variar; evita reutilizar contraseñas y activa la autenticación multifactor (MFA).

Instrucciones de uso

Selecciona la longitud y el conjunto de caracteres (minúsculas/mayúsculas/números/símbolos); activa opcionalmente 'Evitar caracteres similares' y 'Requerir cada tipo'
Para un control más detallado: excluye caracteres o grupos específicos, o selecciona grupos de símbolos predefinidos
Haz clic en generar; si necesitas múltiples resultados, activa la generación por lotes y copia todos con un solo clic
Para validar una contraseña existente, usa el 'Probador de políticas'; para generar frases fáciles de recordar, usa el 'Generador de frases de contraseña'

Características

Fuente aleatoria segura (Web Crypto)
Conjuntos de caracteres y grupos de símbolos configurables
Filtrado de caracteres similares y exclusión personalizada
Generación por lotes, garantía de unicidad y estadísticas de duplicados
Medición de intensidad y entropía
Probador de políticas y generador de frases de contraseña
Ejemplos de código en múltiples lenguajes （JS、Python、PHP、Go、Java、C#、Rust）
Copiar con un solo clic (individual o todos)

Ejemplos de generación de contraseñas

Fuerte (Strong)

Longitud 24, incluye mayúsculas/minúsculas/números/símbolos

Fácil de recordar (Memorable)

Longitud 16, incluye mayúsculas/minúsculas/números, evita caracteres similares

Base de conocimientos sobre contraseñas

1) Fortaleza de la contraseña y entropía

Entropía ≈ log2(tamaño del conjunto de caracteres) × longitud; la longitud suele tener un impacto mayor
Objetivo recomendado: cuentas normales ≥ 80 bits; cuentas con alto privilegio o financieras ≥ 110 bits
Un conjunto de caracteres más amplio y una longitud mayor → mayor resistencia a intentos de adivinación

2) Longitud vs complejidad

Añadir símbolos aleatoriamente es menos efectivo que aumentar la longitud
Evita patrones predecibles fijos (por ejemplo, siempre «mayúscula inicial + número al final!»)
Prioriza garantizar una longitud suficiente, luego mejora ligeramente la diversidad de caracteres

3) Errores comunes y anti-patrones

Secuencias del teclado (qwerty), bloques repetidos, fechas de cumpleaños/años, etc., son fáciles de adivinar mediante reglas
Usar «contraseña raíz + sufijo del sitio» es una reutilización variable, lo que concentra riesgos y facilita su adivinación
No reutilices la misma contraseña en múltiples sitios

4) Recomendaciones para la gestión de contraseñas

Utiliza un gestor de contraseñas; usa una contraseña única por sitio; activa MFA en cuentas importantes
Evita transmitir contraseñas en texto plano por canales públicos; si es necesario, utiliza contraseñas de fácil pronunciación
Cambia inmediatamente y asegura unicidad si descubres que tu contraseña ha sido comprometida o reutilizada

5) Guía para frases de contraseña (Passphrase)

Combinaciones de 4–6 palabras suelen ser fuertes y fáciles de recordar
Mezcla separadores, mayúsculas iniciales e inserta números para mejorar la fortaleza y legibilidad
Evita concatenar directamente frases comunes, letras de canciones o citas famosas

Guía de prácticas seguras para contraseñas

Mejores prácticas

Utiliza contraseñas lo suficientemente largas: 16+ caracteres para cuentas generales, 24+ para cuentas críticas
Para memorización, prioriza frases de contraseña; las contraseñas aleatorias y de alta intensidad deben guardarse en un gestor de contraseñas
Habilita la autenticación multifactor (MFA) siempre que sea posible
No reutilices contraseñas entre sitios web; cada cuenta debe tener una contraseña única

Entropía e intensidad

La entropía mide la impredecibilidad basada en la longitud y el tamaño del conjunto de caracteres; cuanto mayor sea el número de bits de entropía, generalmente más fuerte será la contraseña.

Aumentar la longitud proporciona el mayor beneficio en términos de seguridad
Utiliza conjuntos de caracteres variados siempre que sea posible
Excluir demasiados caracteres reduce el conjunto disponible y debilita la contraseña

Políticas y rotación

Prioriza la longitud y listas negras de contraseñas comunes o comprometidas sobre reglas complejas de composición
Evita rotaciones forzadas frecuentes; cambia solo tras una filtración o riesgo identificado
Utiliza listas de contraseñas comprometidas para bloquear contraseñas comunes o expuestas

Frases de contraseña

Usa 4–6 palabras aleatorias conectadas por separadores, por ejemplo: lake-CARROT-planet_7
Evita frases comunes como citas famosas o letras de canciones; la aleatoriedad es más importante que la 'ingeniosidad'
Para cuentas críticas, recomienda usar un gestor de contraseñas para almacenar contraseñas aleatorias de alta entropía

Sugerencias de configuración de generación

"Require each selected set" asegura que al menos un carácter de cada conjunto seleccionado esté presente
"Avoid similar" mejora la legibilidad, pero reduce ligeramente el tamaño del conjunto de caracteres
Puedes limitar los símbolos a un subconjunto aceptado por el sistema objetivo

Almacenamiento en el servidor

Nunca almacenes contraseñas en texto plano; usa hash fuertes (Argon2id/PBKDF2/BCrypt) con sal
Configura parámetros adecuados (memoria/tiempo/costo); considera usar pepper si es necesario
Limita la tasa de intentos y monitorea los fallos; durante ataques, implementa CAPTCHA o verificación de dispositivo

Autenticación multifactor y recuperación

Prioriza TOTP o claves de hardware; evita尽可能 SMS
Protege el proceso de recuperación: utiliza múltiples factores o verificación por correo electrónico con un periodo de enfriamiento
Proporciona códigos de recuperación de respaldo y recomienda al usuario guardarlos con cuidado

Protección contra ataques de fuerza bruta

Implementa retrasos progresivos o bloqueos junto con puntuaciones de riesgo por IP/dispositivo
Configura WAF y límites de tasa para APIs y formularios de inicio de sesión
Monitorea intentos de credential stuffing y anima a los usuarios a usar contraseñas únicas

Almacenamiento y procesamiento local

Utiliza un gestor de contraseñas confiable para guardar y rellenar automáticamente
No compartas contraseñas en texto plano por chat o correo; usa herramientas de gestión de secretos para equipos
Si necesitas anotar contraseñas físicamente, asegúrate de que el almacenamiento físico sea seguro

Declaramos: Esta herramienta genera contraseñas localmente en el navegador usando Web Crypto; no envía ningún dato al servidor.

Cómo generar contraseñas mediante lenguajes de programación

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

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

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}