Generador de cadenas aleatorias
Un generador de cadenas aleatorias online y gratuito. Criptográficamente seguro, con distribución uniforme, y nunca envía nada a un servidor.
Más opciones
Sobre este generador de cadenas aleatorias
Un generador de cadenas aleatorias produce una secuencia de caracteres en la que cada posición se elige al azar de un alfabeto que tú decides. Los desarrolladores usan cadenas aleatorias como claves de API, tokens de sesión, enlaces para restablecer contraseñas, identificadores de bases de datos, nombres de archivo, códigos de invitación y datos de prueba. Lo único que separa uno bueno de uno malo es de dónde sale la aleatoriedad y cómo se convierte en caracteres, y ninguna de las dos cosas se ve en el resultado. Una cadena que parece aleatoria no es lo mismo que una que lo es.
Este generador de cadenas aleatorias funciona online en la pestaña de tu navegador y nunca en un servidor. Usa la misma fuente criptográfica que tu sistema operativo ofrece a los gestores de contraseñas y a las bibliotecas TLS, la convierte en caracteres sin sesgo y te dice exactamente cuánta entropía tiene el resultado. Es gratis, no necesita cuenta y sigue funcionando si te desconectas de la red una vez cargada la página.
Cómo usarlo
- Fija la longitud con la casilla numérica o con el control deslizante. El valor por defecto es de 24 caracteres, el control deslizante va de 1 a 128 y la casilla numérica admite hasta 4096.
- Elige un juego de caracteres. Los botones activan o desactivan mayúsculas, minúsculas, dígitos y símbolos, y el desplegable ofrece alfabetos listos para usar, como hexadecimal, Base58, Base32 y Base64 apto para URL.
- Pulsa Generar o la tecla G. Arriba aparece una cadena nueva, con su fortaleza en bits debajo.
- Pulsa Copiar. Para más de un valor, abre Más opciones, indica una cantidad de hasta 10.000 y elige uno por línea, separados por comas, un array JSON, una lista entre comillas o asignaciones
.env; después copia o descarga todo el lote.
Cadenas aleatorias con caracteres especiales
Al activar el botón de símbolos se añaden doce caracteres especiales: ! # $ % * + - = ? @ ^ _. Ese conjunto está elegido a propósito. Todos ellos figuran en las listas de caracteres permitidos para contraseñas de Microsoft Entra ID, Active Directory y OWASP, y ninguno rompe un comando de shell, una URL o un valor de configuración entre comillas, como sí hacen una barra invertida, una comilla o un espacio. Junto con letras y dígitos da un alfabeto de 74 caracteres, o 6,2095 bits por carácter, solo un 5,3 % por debajo del conjunto completo de 94 caracteres ASCII imprimibles. Si necesitas todos los símbolos, o una selección distinta, escribe tu propio alfabeto en el campo de juego de caracteres personalizado. La página sobre cadenas aleatorias con caracteres especiales (en inglés) explica qué sistemas rechazan qué símbolos.
Cadenas aleatorias largas
Un generador de cadenas aleatorias largas sirve para claves de cifrado, secretos de firma y para llenar un campo hasta su límite y ver qué se rompe. Esta herramienta genera una sola cadena de hasta 4096 caracteres, con el mismo muestreo sin sesgo a cualquier longitud. Longitud y alfabeto se multiplican: 24 letras y dígitos aportan unos 143 bits, que ya es más de lo que puede alcanzar cualquier ataque de fuerza bruta, mientras que 64 caracteres aportan unos 381 bits. A partir de unos 128 bits, un secreto más largo deja de añadir seguridad práctica y solo añade tamaño, así que ajusta la longitud a lo que necesitas. El generador de cadenas de 64 caracteres y la calculadora de entropía (ambos en inglés) muestran la aritmética para cualquier combinación.
Qué hace seguro a un generador de cadenas aleatorias
Dos cosas, y la mayoría de los generadores falla al menos en una. La primera es la fuente. Un generador de cadenas aleatorias seguro lee de un generador de números aleatorios criptográficamente seguro: crypto.getRandomValues() en el navegador, que obtiene los datos del sistema operativo. Muchas herramientas online siguen usando Math.random(), que es rápido y sirve para juegos, pero resulta predecible para cualquiera que observe unas pocas salidas. Se explica en detalle en por qué Math.random() no es seguro (en inglés).
La segunda es la conversión. Tomar un número aleatorio módulo el tamaño del alfabeto hace que unos caracteres sean más probables que otros, y este generador lo evita con muestreo por rechazo, como se describe más abajo y en el sesgo del módulo explicado (en inglés). Las pruebas estadísticas que lo confirman están publicadas en la página de metodología, junto a una implementación deliberadamente defectuosa que esas mismas pruebas detectan.
Online o en tu propio código
Un generador de cadenas aleatorias online es la opción más rápida cuando necesitas un valor ya: un secreto para un archivo .env, un dato de prueba, una contraseña puntual. Cuando la cadena tiene que crearse dentro de una aplicación en tiempo de ejecución, genérala en ese lenguaje en lugar de pegarla. Los ejemplos que aparecen más abajo en esta página muestran el enfoque correcto para cada plataforma:
- Python: el módulo
secrets, nuncarandom. - Java:
SecureRandom, nuncajava.util.Random. - JavaScript:
crypto.getRandomValues()en el navegador y en Node.js, nuncaMath.random(). - C++:
std::uniform_int_distributionsobrestd::random_device, o libsodium cuando se necesita una garantía. - PHP:
random_int(), nuncarand()nimt_rand(). - C#:
RandomNumberGenerator.GetString()en .NET 8, oGetInt32()en .NET 6 y 7. - PowerShell:
RandomNumberGeneratoren PowerShell 7, oGet-Random -Maximumpor carácter en 5.1. Nunca añadas-SetSeedy nunca construyas la cadena con-Count.
Cómo elegir entre herramientas para generar cadenas aleatorias
La mayoría de las herramientas para generar cadenas aleatorias se parecen, así que júzgalas por lo que puedes comprobar. ¿El valor se crea en tu navegador o se devuelve desde un servidor donde puede quedar registrado? ¿El sitio dice qué fuente aleatoria usa? ¿La cifra de fortaleza baja cuando exiges todos los tipos de caracteres, como debería? ¿Puedes excluir caracteres que se parecen, como 0 O 1 l I, en cadenas que tienen que leer personas? Abre las herramientas de desarrollo del navegador, ve a la pestaña Red y pulsa Generar: en este sitio no aparece nada. Para trabajos más específicos, consulta el generador de cadenas aleatorias en lote, el generador con caracteres personalizados, el generador de contraseñas o todos los generadores del sitio (en inglés).
Cómo funciona este generador
Cada valor sale de crypto.getRandomValues(), la interfaz del navegador con el generador de números aleatorios criptográfico del sistema operativo. No hay alternativa de respaldo: si un navegador no puede ofrecer una fuente segura, esta herramienta se niega a generar en lugar de usar en silencio una más débil.
Convertir esos bits en caracteres es donde fallan la mayoría de los generadores. El enfoque obvio, tomar el resto de dividir un número aleatorio entre el tamaño del alfabeto, no divide de forma exacta y desvía el resultado hacia los caracteres del principio del alfabeto. Asignar un solo byte a 62 caracteres hace que los ocho primeros sean 1,25 veces más probables que los otros cincuenta y cuatro. Esta herramienta descarta los valores que caen en el último ciclo incompleto, así que todos los caracteres son exactamente igual de probables.
El mismo cuidado se aplica a la opción de exigir uno de cada tipo. En lugar de forzar un dígito en una posición fija, lo que deja un patrón visible, el generador produce una cadena candidata completa y la rechaza si no cumple la restricción. Todas las cadenas válidas son igual de probables, y la lectura de entropía baja a la cifra real en lugar de la que da la fórmula ingenua.
Publicamos los resultados de las pruebas en lugar de pedirte que te fíes. En 500.000 caracteres generados, la prueba chi cuadrado de frecuencia de caracteres da p = 0,673. La misma batería aplicada a una implementación deliberadamente sesgada la detecta con chi cuadrado = 3345 y 61 grados de libertad, y así sabemos que las pruebas son lo bastante sensibles para que el resultado limpio signifique algo. Lee la metodología completa (en inglés).
Cómo hacerlo en tu propio código
Si lo necesitas dentro de una aplicación y no en una pestaña del navegador, esta es la forma correcta de hacerlo en cada lenguaje. Cada ejemplo usa la fuente criptográfica de esa plataforma y una conversión sin sesgo.
JavaScript (navegador y Node 19+)
const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
function randomString(length) {
const n = ALPHABET.length;
// Largest multiple of n that fits in a uint32. Values at or above this
// are discarded, which is what removes the modulo bias.
const limit = Math.floor(2 ** 32 / n) * n;
const out = new Array(length);
const buf = new Uint32Array(length);
crypto.getRandomValues(buf);
for (let i = 0, j = 0; i < length; i++) {
let v = buf[j++];
while (v >= limit) {
// Refill one word at a time on the rare rejection.
const extra = new Uint32Array(1);
crypto.getRandomValues(extra);
v = extra[0];
}
out[i] = ALPHABET[v % n];
}
return out.join("");
}
randomString(24);crypto.getRandomValues() rechaza una única petición de más de 65536 bytes, así que un lote grande tiene que dividirse en partes.
Python 3.6+
import secrets
import string
ALPHABET = string.ascii_letters + string.digits
def random_string(length: int) -> str:
# secrets.choice() is unbiased: it uses randbelow(), which is itself
# rejection sampling over os.urandom. Do not use random.choice() here,
# which is a Mersenne Twister and is not cryptographically secure.
return "".join(secrets.choice(ALPHABET) for _ in range(length))
random_string(24)secrets está en la biblioteca estándar desde la versión 3.6. Cualquier cosa que use el módulo random es la herramienta equivocada para un secreto.
Go
package main
import (
"crypto/rand"
"math/big"
)
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
func randomString(length int) (string, error) {
out := make([]byte, length)
max := big.NewInt(int64(len(alphabet)))
for i := range out {
// rand.Int is unbiased; it rejects internally.
n, err := rand.Int(rand.Reader, max)
if err != nil {
return "", err
}
out[i] = alphabet[n.Int64()]
}
return string(out), nil
}crypto/rand, nunca math/rand. Desde Go 1.20, el generador global de math/rand recibe por sí solo una semilla aleatoria, lo que no mejora en nada su previsibilidad.
Rust
// rand = "0.9"
use rand::Rng;
use rand::distr::{Alphanumeric, SampleString};
fn random_string(length: usize) -> String {
// rand::rng() is a thread-local ChaCha12 CSPRNG, seeded from the
// operating system and reseeded periodically.
// Alphanumeric samples uniformly over A-Z a-z 0-9.
Alphanumeric.sample_string(&mut rand::rng(), length)
}
// With an arbitrary alphabet, random_range rejection-samples:
fn random_from(alphabet: &[u8], length: usize) -> String {
let mut rng = rand::rng();
(0..length)
.map(|_| alphabet[rng.random_range(0..alphabet.len())] as char)
.collect()
}En rand 0.8 las rutas son distintas: rand::distributions en lugar de rand::distr, DistString en lugar de SampleString, gen_range en lugar de random_range y rand::thread_rng() en lugar de rand::rng().
PHP 7+
<?php
function randomString(int $length): string {
$alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
$n = strlen($alphabet);
$out = '';
for ($i = 0; $i < $length; $i++) {
// random_int() is unbiased and cryptographically secure.
// rand() and mt_rand() are neither.
$out .= $alphabet[random_int(0, $n - 1)];
}
return $out;
}
echo randomString(24);Java 17+
import java.security.SecureRandom;
public final class RandomString {
private static final String ALPHABET =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
private static final SecureRandom RANDOM = new SecureRandom();
public static String generate(int length) {
StringBuilder sb = new StringBuilder(length);
for (int i = 0; i < length; i++) {
// nextInt(bound) rejects internally, so it is unbiased.
sb.append(ALPHABET.charAt(RANDOM.nextInt(ALPHABET.length())));
}
return sb.toString();
}
}SecureRandom, no java.util.Random ni Math.random(), que son generadores congruenciales lineales de 48 bits.
C# / .NET 6+
using System.Security.Cryptography;
public static class RandomStringGenerator
{
private const string Alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
public static string Generate(int length)
{
// GetString was added in .NET 8 and is unbiased.
return RandomNumberGenerator.GetString(Alphabet, length);
}
// On .NET 6 and 7, GetInt32 is the unbiased primitive:
public static string GenerateLegacy(int length)
{
var chars = new char[length];
for (int i = 0; i < length; i++)
chars[i] = Alphabet[RandomNumberGenerator.GetInt32(Alphabet.Length)];
return new string(chars);
}
}C++11 y posteriores
#include <random>
#include <string>
std::string random_string(std::size_t length) {
static const std::string alphabet =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
// uniform_int_distribution is specified to give every value in the range
// equal probability, so there is no modulo bias to remove by hand.
std::random_device rd;
std::uniform_int_distribution<std::size_t> pick(0, alphabet.size() - 1);
std::string out;
out.reserve(length);
for (std::size_t i = 0; i < length; ++i) {
out += alphabet[pick(rd)];
}
return out;
}std::random_device lee la fuente del sistema operativo en libstdc++, libc++ y MSVC, pero el estándar permite que sea determinista, y las compilaciones de MinGW anteriores a GCC 9.2 lo eran. Cuando la garantía importa, usa randombytes_uniform() de libsodium. Nunca uses std::rand() ni std::mt19937 para un secreto.
PowerShell 7
$chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
# GetInt32 draws from the OS CSPRNG and rejection samples internally.
-join (1..24 | ForEach-Object {
$chars[[System.Security.Cryptography.RandomNumberGenerator]::GetInt32($chars.Length)]
})Windows PowerShell 5.1 se ejecuta sobre .NET Framework, que no tiene GetInt32. Allí, elige cada carácter con Get-Random -Maximum $chars.Length, que usa el CSPRNG del sistema salvo que se indique -SetSeed. Evita Get-Random -Count, que nunca repite un carácter.
Shell
# 24 alphanumeric characters from the kernel CSPRNG.
LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 24; echo
# Base64, URL-safe, from 32 bytes of entropy.
openssl rand -base64 32 | tr '+/' '-_' | tr -d '='tr descarta los bytes que quedan fuera del conjunto en lugar de plegarlos dentro, así que esta tubería no tiene sesgo. Poner `head -c 24` antes de `tr` da el subconjunto alfanumérico de 24 bytes brutos, que es una cadena más corta y de longitud variable, no 24 caracteres.
Guías completas (en inglés) con tokens, contraseñas, generación en lote y los errores habituales en cada lenguaje, con cada ejemplo ejecutado en el entorno real:
Cómo elegir la longitud
La longitud solo tiene sentido junto con el alfabeto. Una cadena de 20 dígitos aporta unos 66 bits; 20 caracteres tomados de las 62 letras y dígitos aportan 119. La tabla indica cuántos caracteres necesitas para alcanzar una fortaleza dada, y el generador muestra la cifra exacta para lo que tengas seleccionado.
| Alfabeto | Bits/carácter | 64 bits | 112 bits | 128 bits |
|---|---|---|---|---|
| Solo dígitos (10) | 3,3219 | 20 | 34 | 39 |
| Letras minúsculas (26) | 4,7004 | 14 | 24 | 28 |
| Hex (16) | 4,0000 | 16 | 28 | 32 |
| Letras y dígitos (62) | 5,9542 | 11 | 19 | 22 |
| Sin caracteres parecidos (49) | 5,6147 | 12 | 20 | 23 |
| Con símbolos seguros (74) | 6,2095 | 11 | 19 | 21 |
Excluir los caracteres que se parecen cuesta 0,3395 bits por carácter, un 5,70 %. Un carácter extra cada diecisiete lo compensa, y normalmente merece la pena para cualquier cosa que una persona tenga que leer en voz alta o volver a escribir.
Preguntas frecuentes
¿Qué es un generador de cadenas aleatorias?
Un generador de cadenas aleatorias es una herramienta que construye una cadena eligiendo cada carácter al azar de un alfabeto, como letras, dígitos y símbolos. Uno bueno usa una fuente aleatoria criptográficamente segura y da a cada carácter exactamente la misma probabilidad, de modo que el resultado no se puede predecir ni reproducir.
¿Para qué se usa una cadena aleatoria?
Las cadenas aleatorias se usan como claves de API, tokens de sesión, enlaces para restablecer la contraseña y verificar el correo, tokens CSRF, contraseñas, secretos de cifrado y firma, identificadores de bases de datos y archivos, códigos de cupones e invitaciones, y datos de prueba para comprobar cómo maneja una aplicación una entrada de cierta longitud.
¿Es seguro usar un generador de cadenas aleatorias online?
Es seguro cuando la cadena se genera en tu navegador y nunca se envía a ningún sitio, y cuando la herramienta usa una fuente aleatoria segura. Puedes comprobarlo tú mismo en este sitio: abre la pestaña Red en las herramientas de desarrollo del navegador, pulsa Generar y no aparece ninguna petición. Un generador que crea el valor en un servidor tiene que enviártelo, así que podría quedar registrado por el camino.
¿Este generador de cadenas aleatorias online es gratis?
Sí. Es gratis, no hay cuenta, no hay límite de uso y no hay restricciones para el uso comercial. Funciona online en tu navegador y, una vez cargada la página, sigue funcionando también sin conexión.
¿Cómo genero una cadena aleatoria con caracteres especiales?
Activa el botón !#$%. Añade doce símbolos, ! # $ % * + - = ? @ ^ _, que aceptan casi todas las políticas de contraseñas y que no rompen comandos de shell ni URL. Para otro conjunto de símbolos, escribe exactamente el alfabeto que quieras en el campo de juego de caracteres personalizado, dentro de Más opciones.
¿Cómo genero una cadena aleatoria larga?
Escribe la longitud en la casilla numérica junto al control deslizante. El control deslizante llega a 128, pero la casilla admite cualquier longitud hasta 4096 caracteres. La lectura de entropía se actualiza mientras escribes, así que ves cuándo la cadena es lo bastante larga para lo que necesitas.
¿Cómo genero una cadena alfanumérica aleatoria?
Deja activados los botones A-Z, a-z y 0-9 y desactivado el de símbolos, que es la configuración por defecto. Eso da un alfabeto de 62 caracteres, unos 5,95 bits por carácter, así que una cadena de 24 caracteres aporta unos 143 bits. Para usar solo letras, desactiva 0-9; para usar solo números, desactiva los dos botones de letras.
¿Puedo generar varias cadenas aleatorias a la vez?
Sí. Abre Más opciones e indica una cantidad de hasta 10.000. Los resultados pueden mostrarse uno por línea, separados por comas, como array JSON, como lista entre comillas o como asignaciones .env, y copiarse o descargarse como archivo. Marca «Todos los resultados deben ser distintos entre sí» si el lote no puede contener duplicados.
¿Las cadenas aleatorias son únicas?
No hay garantía, pero una cadena lo bastante larga es única en la práctica. Los duplicados siguen la cota del cumpleaños: con unos 143 bits, que son 24 letras y dígitos, tendrías que generar alrededor de 2^71 cadenas antes de que una repetición sea probable. Con cadenas cortas es distinto; un código de 6 caracteres se repite mucho antes, así que comprueba la unicidad en tu base de datos cuando la cadena sea corta.
¿Qué hace seguro a un generador de cadenas aleatorias?
Una fuente aleatoria criptográficamente segura, como crypto.getRandomValues() en el navegador, y una conversión sin sesgo de números aleatorios a caracteres. Un generador basado en Math.random() es predecible, y uno que usa el operador de resto sin muestreo por rechazo hace que algunos caracteres sean más probables que otros. Esta herramienta no hace ninguna de las dos cosas y publica los resultados de sus pruebas.
¿Cómo genero una cadena aleatoria en Python?
Usa el módulo secrets: "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(24)). secrets.choice es criptográficamente seguro y no tiene sesgo. No uses random.choice, que es un Mersenne Twister y se puede predecir a partir de su salida.
¿Cómo genero una cadena aleatoria en Java?
Crea un único java.security.SecureRandom y llama a nextInt(alphabet.length()) para cada carácter, añadiendo alphabet.charAt() a un StringBuilder. nextInt con límite no tiene sesgo. No uses java.util.Random ni Math.random(), que son generadores predecibles de 48 bits.
¿Cómo genero una cadena aleatoria en JavaScript?
Llena un Uint32Array con crypto.getRandomValues(), descarta los valores iguales o superiores al mayor múltiplo del tamaño del alfabeto e indexa el alfabeto con el resto. Funciona en todos los navegadores modernos y en Node.js 19 y posteriores. La función completa está en los ejemplos de código de esta página. Math.random() no es seguro para esto.
¿Cómo genero una cadena aleatoria en C++?
Usa std::uniform_int_distribution sobre std::random_device e indexa tu alfabeto. La distribución no tiene sesgo por especificación. std::random_device lee la fuente del sistema operativo en los principales compiladores, pero el estándar no lo garantiza, así que usa randombytes_uniform() de libsodium cuando eso importe. Evita std::rand().
¿Cómo genero una cadena aleatoria en PHP?
Llama a random_int(0, strlen($alphabet) - 1) para cada carácter y añade el carácter de esa posición. random_int es criptográficamente seguro, no tiene sesgo y viene incluido desde PHP 7. No uses rand(), mt_rand() ni str_shuffle() para nada secreto.
¿Cómo genero una cadena aleatoria en C#?
En .NET 8 y posteriores, llama a RandomNumberGenerator.GetString(alphabet, length), que es seguro y sin sesgo en una sola línea. En .NET 6 y 7, llama a RandomNumberGenerator.GetInt32(alphabet.Length) para cada carácter. System.Random no sirve para secretos.
¿Cómo genero una cadena aleatoria en PowerShell?
En PowerShell 7.4 y posteriores, llama a [System.Security.Cryptography.RandomNumberGenerator]::GetString($chars, 24). En Windows PowerShell 5.1, que no tiene ese método, añade $chars[(Get-Random -Maximum $chars.Length)] una vez por carácter. Get-Random obtiene los datos del generador criptográfico del sistema salvo que pases -SetSeed. Evita Get-Random -Count, que nunca repite un carácter.
¿Cómo genero una cadena aleatoria en Node.js?
Para una cadena hexadecimal o apta para URL, usa crypto.randomBytes(16).toString("hex") o crypto.randomBytes(18).toString("base64url"). Para un alfabeto personalizado, elige cada carácter con crypto.randomInt(alphabet.length), que es seguro y sin sesgo. No construyas secretos con Math.random().
¿Cómo genero una cadena aleatoria en Linux o Bash?
Ejecuta LC_ALL=C tr -dc "A-Za-z0-9" < /dev/urandom | head -c 24 para 24 letras y dígitos, u openssl rand -hex 16 para una cadena hexadecimal de 32 caracteres. Ambos leen la fuente aleatoria del kernel. Evita $RANDOM, que es un valor de 15 bits procedente de un generador no criptográfico.
¿Cómo genero una cadena aleatoria en Go?
Usa crypto/rand. Desde Go 1.24, rand.Text() devuelve una cadena Base32 de 26 caracteres con al menos 128 bits de aleatoriedad. Para tu propio alfabeto, elige cada carácter con rand.Int(rand.Reader, big.NewInt(int64(len(alphabet)))). Nunca uses math/rand para secretos.
¿Cómo genero una cadena aleatoria en Excel?
En Excel 365, =TEXTJOIN("",TRUE,CHAR(RANDARRAY(10,1,65,90,TRUE))) da 10 letras mayúsculas aleatorias y cambia cada vez que se recalcula la hoja. En Excel en español la misma fórmula suele escribirse =UNIRCADENAS("";VERDADERO;CARACTER(MATRIZALEAT(10;1;65;90;VERDADERO))). Las funciones aleatorias de Excel no son criptográficamente seguras, así que úsala solo para datos de prueba y genera contraseñas o claves con una herramienta segura.
¿Se envía a un servidor algo de lo que genero?
No. La generación se ejecuta por completo en tu navegador con la Web Crypto API. No hay ningún servidor al que enviarlo, y puedes confirmarlo tú mismo: abre las herramientas de desarrollo del navegador, ve a la pestaña Red y pulsa Generar. No aparece nada.
¿En qué se diferencia de usar Math.random()?
Math.random() no es criptográficamente seguro. V8 lo implementa con xorshift128+, un generador no criptográfico de 128 bits, y la especificación de JavaScript no exige que su salida sea impredecible. Hay trabajos publicados que muestran que alguien que observe unas pocas salidas puede recuperar el estado interno y reproducir todos los valores pasados y futuros. Esta herramienta usa crypto.getRandomValues(), que obtiene los datos del CSPRNG del sistema operativo.
¿Qué es el sesgo del módulo y lo tiene esta herramienta?
Reducir un número aleatorio con el operador de resto desvía el resultado hacia el principio del alfabeto. Asignar un byte a 62 caracteres da 256 = 4x62 + 8, así que los ocho primeros caracteres son 1,25 veces más probables que el resto. Esta herramienta lo elimina con muestreo por rechazo: los valores que caen en el último ciclo incompleto se descartan en lugar de incorporarse.
¿Por qué baja la cifra de entropía cuando exijo todos los tipos de caracteres?
Porque debe bajar. Exigir al menos un dígito prohíbe todas las cadenas sin dígitos, así que hay menos resultados posibles y la entropía real es menor que longitud x log2(tamaño del alfabeto). La mayoría de los generadores siguen mostrando la cifra más alta. Este cuenta las cadenas válidas por inclusión-exclusión y muestra la cifra real, con la cifra sin restricciones entre paréntesis para que veas el coste.
¿Qué longitud debe tener una cadena aleatoria?
Depende de lo que proteja. Para un valor que un atacante solo puede adivinar online contra un servicio con límite de peticiones, 64 bits es holgado. Para un secreto que podría capturarse y atacarse sin conexión, apunta a 112 bits o más; 19 caracteres alfanuméricos llegan a 113 bits. Para una contraseña, NIST SP 800-63B exige un mínimo de 15 caracteres y desaconseja expresamente las reglas de composición.
¿Puedo usarlo para contraseñas, claves de API y tokens de sesión?
Sí. La fuente de aleatoriedad es la misma que tu sistema operativo ofrece a cualquier aplicación, y la conversión a caracteres no tiene sesgo. Lo que la herramienta no puede hacer es proteger el valor una vez que sale de esta página, así que trata el resultado como tratarías cualquier otro secreto.
Velocidad
Generar 10.000 cadenas de 32 caracteres lleva 17 ms. Los lotes grandes se producen por partes, liberando el hilo principal entre una y otra, así que la página sigue respondiendo y la ejecución se puede cancelar. Tres de los generadores que aparecen ahora en la primera página de Google no tienen ningún límite de cantidad y congelan la pestaña.