Gerador de strings aleatórias
Um gerador de strings aleatórias online e gratuito. Criptograficamente seguro, com distribuição uniforme, e nada é enviado a um servidor.
Mais opções
Sobre este gerador de strings aleatórias
Um gerador de strings aleatórias produz uma sequência de caracteres em que cada posição é sorteada de um alfabeto escolhido por você. Desenvolvedores usam strings aleatórias como chaves de API, tokens de sessão, links de redefinição de senha, identificadores de banco de dados, nomes de arquivo, códigos de convite e dados de teste. A única coisa que separa um gerador bom de um ruim é a origem da aleatoriedade e a forma como ela vira caracteres, e nenhuma das duas aparece no resultado. Uma string que parece aleatória não é a mesma coisa que uma string que é aleatória.
Este gerador de strings aleatórias funciona online, na aba do seu navegador, e nunca em um servidor. Ele usa a mesma fonte criptográfica que o seu sistema operacional oferece aos gerenciadores de senhas e às bibliotecas TLS, converte essa fonte em caracteres sem viés e informa exatamente quanta entropia o resultado tem. É gratuito, não pede cadastro e continua funcionando se você se desconectar da rede depois que a página carregar.
Como usar
- Defina o comprimento na caixa numérica ou no controle deslizante. O padrão é 24 caracteres, o controle deslizante vai de 1 a 128 e a caixa numérica aceita até 4.096.
- Escolha um conjunto de caracteres. Os botões ligam ou desligam maiúsculas, minúsculas, dígitos e símbolos, e a lista suspensa oferece alfabetos prontos, como hexadecimal, Base58, Base32 e Base64 seguro para URL.
- Clique em Gerar ou pressione a tecla G. Uma string nova aparece no topo, com a força em bits logo abaixo.
- Clique em Copiar. Para mais de um valor, abra Mais opções, defina uma quantidade de até 10.000 e escolha um por linha, separados por vírgula, array JSON, lista entre aspas ou atribuições
.env; depois copie ou baixe o lote inteiro.
Strings aleatórias com caracteres especiais
Ativar o botão de símbolos adiciona doze caracteres especiais: ! # $ % * + - = ? @ ^ _. Esse conjunto foi escolhido de propósito. Todos eles estão nas listas de caracteres permitidos em senhas do Microsoft Entra ID, do Active Directory e da OWASP, e nenhum quebra um comando de shell, uma URL ou um valor de configuração entre aspas, como fazem a barra invertida, as aspas ou o espaço. Junto com letras e dígitos, forma um alfabeto de 74 caracteres, ou 6,2095 bits por caractere, apenas 5,3% abaixo do conjunto completo de 94 caracteres ASCII imprimíveis. Se você precisa de todos os símbolos, ou de outra seleção, digite seu próprio alfabeto no campo de conjunto de caracteres personalizado. A página sobre strings aleatórias com caracteres especiais (em inglês) explica quais sistemas rejeitam quais símbolos.
Strings aleatórias longas
Um gerador de strings aleatórias longas é útil para chaves de criptografia, segredos de assinatura e para preencher um campo até o limite e ver o que quebra. Esta ferramenta gera uma única string de até 4.096 caracteres, com a mesma amostragem sem viés em qualquer comprimento. Comprimento e alfabeto se multiplicam: 24 letras e dígitos carregam cerca de 143 bits, o que já é mais do que qualquer ataque de força bruta consegue alcançar, enquanto 64 caracteres carregam cerca de 381 bits. A partir de uns 128 bits, um segredo mais longo deixa de acrescentar segurança prática e passa a acrescentar só tamanho, então ajuste o comprimento ao uso. O gerador de strings de 64 caracteres e a calculadora de entropia (ambos em inglês) mostram a conta para qualquer combinação.
O que torna um gerador de strings aleatórias seguro
Duas coisas, e a maioria dos geradores erra pelo menos uma delas. A primeira é a fonte. Um gerador de strings aleatórias seguro lê de um gerador de números aleatórios criptograficamente seguro: crypto.getRandomValues() no navegador, que obtém os dados do sistema operacional. Muitas ferramentas online ainda usam Math.random(), que é rápido e serve para jogos, mas é previsível para qualquer pessoa que observe algumas saídas. Isso é explicado em detalhes em por que Math.random() não é seguro (em inglês).
A segunda é a conversão. Tirar o módulo de um número aleatório pelo tamanho do alfabeto deixa alguns caracteres mais prováveis que outros, e este gerador elimina isso com amostragem por rejeição, como descrito abaixo e em viés do módulo explicado (em inglês). Os testes estatísticos que confirmam isso estão publicados na página de metodologia, ao lado de uma implementação propositalmente defeituosa que os mesmos testes detectam.
Online ou no seu próprio código
Um gerador de strings aleatórias online é a opção mais rápida quando você precisa de um valor agora: um segredo para um arquivo .env, um dado de teste, uma senha avulsa. Quando a string precisa ser criada dentro de uma aplicação em tempo de execução, gere-a nessa linguagem em vez de colar o valor. Os exemplos mais abaixo nesta página mostram a abordagem correta para cada plataforma:
- Python: o módulo
secrets, nuncarandom. - Java:
SecureRandom, nuncajava.util.Random. - JavaScript:
crypto.getRandomValues()no navegador e no Node.js, nuncaMath.random(). - C++:
std::uniform_int_distributionsobrestd::random_device, ou libsodium quando uma garantia for necessária. - PHP:
random_int(), nuncarand()nemmt_rand(). - C#:
RandomNumberGenerator.GetString()no .NET 8, ouGetInt32()no .NET 6 e 7. - PowerShell:
RandomNumberGeneratorno PowerShell 7, ouGet-Random -Maximumpara cada caractere no 5.1. Nunca adicione-SetSeede nunca monte a string com-Count.
Como escolher entre ferramentas de strings aleatórias
A maioria das ferramentas de strings aleatórias parece igual, então julgue pelo que dá para conferir. O valor é criado no seu navegador ou volta de um servidor onde pode ficar registrado? O site informa qual fonte aleatória usa? O valor de força cai quando você exige todos os tipos de caracteres, como deveria? Dá para excluir caracteres parecidos, como 0 O 1 l I, em strings que pessoas precisam ler? Abra as ferramentas de desenvolvedor do navegador, vá até a aba Rede e clique em Gerar: neste site, nada aparece. Para tarefas mais específicas, veja o gerador de strings aleatórias em lote, o gerador com caracteres personalizados, o gerador de senhas ou todos os geradores do site (em inglês).
Como este gerador funciona
Todo valor vem de crypto.getRandomValues(), a interface do navegador com o gerador de números aleatórios criptográfico do sistema operacional. Não existe plano B: se um navegador não consegue oferecer uma fonte segura, esta ferramenta se recusa a gerar em vez de usar, em silêncio, uma fonte mais fraca.
Transformar esses bits brutos em caracteres é onde a maioria dos geradores erra. A abordagem óbvia, pegar o resto da divisão de um número aleatório pelo tamanho do alfabeto, não divide por igual e puxa o resultado para os caracteres do começo do alfabeto. Mapear um único byte para 62 caracteres deixa os oito primeiros 1,25 vez mais prováveis que os outros cinquenta e quatro. Esta ferramenta descarta os sorteios que caem no último ciclo incompleto, de modo que todos os caracteres têm exatamente a mesma probabilidade.
O mesmo cuidado vale para a opção que exige um de cada tipo. Em vez de forçar um dígito numa posição fixa, o que deixa um padrão visível, o gerador produz uma string candidata inteira e a rejeita se ela não atender à restrição. Todas as strings válidas têm a mesma probabilidade, e o valor de entropia cai para o número real em vez daquele que a fórmula ingênua dá.
Publicamos os resultados dos testes em vez de pedir que você confie na gente. Em 500.000 caracteres gerados, o teste qui-quadrado de frequência de caracteres dá p = 0,673. A mesma bateria aplicada a uma implementação propositalmente enviesada a detecta com qui-quadrado = 3345 e 61 graus de liberdade, e é assim que sabemos que os testes são sensíveis o bastante para o resultado limpo significar algo. Leia a metodologia completa (em inglês).
Como fazer isso no seu próprio código
Se você precisa disso dentro de uma aplicação e não numa aba do navegador, este é o jeito certo em cada linguagem. Cada exemplo usa a fonte criptográfica da plataforma e uma conversão sem viés.
JavaScript (navegador e 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() recusa uma única solicitação acima de 65.536 bytes, então um lote grande precisa ser dividido em 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 faz parte da biblioteca padrão desde o Python 3.6. Qualquer coisa que use o módulo random é a ferramenta errada para um segredo.
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 o Go 1.20, o gerador global de math/rand recebe sozinho uma semente aleatória, o que não melhora em nada a sua previsibilidade.
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()
}No rand 0.8, os caminhos são outros: rand::distributions em vez de rand::distr, DistString em vez de SampleString, gen_range em vez de random_range e rand::thread_rng() em vez 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, e não java.util.Random nem Math.random(), que são geradores congruenciais lineares 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 ou posterior
#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 lê a fonte do sistema operacional na libstdc++, na libc++ e no MSVC, mas o padrão permite que ele seja determinístico, e os builds do MinGW anteriores ao GCC 9.2 eram. Quando a garantia importa, use randombytes_uniform() da libsodium. Nunca use std::rand() nem std::mt19937 para um segredo.
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)]
})O Windows PowerShell 5.1 roda sobre o .NET Framework, que não tem GetInt32. Nele, escolha cada caractere com Get-Random -Maximum $chars.Length, que usa o CSPRNG do sistema, a menos que -SetSeed seja informado. Evite Get-Random -Count, que nunca repete um caractere.
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 '='O tr descarta os bytes fora do conjunto em vez de dobrá-los para dentro dele, então esse pipeline não tem viés. Colocar `head -c 24` antes do `tr` gera só a parte alfanumérica de 24 bytes brutos, que é uma string mais curta e de tamanho variável, e não 24 caracteres.
Guias completos (em inglês) com tokens, senhas, geração em lote e os erros comuns em cada linguagem, com todos os exemplos executados no ambiente real:
Como escolher o comprimento
O comprimento só faz sentido junto com o alfabeto. Uma string de 20 dígitos carrega cerca de 66 bits; 20 caracteres tirados das 62 letras e dígitos carregam 119. A tabela mostra quantos caracteres você precisa para chegar a uma força, e o gerador mostra o valor exato para o que estiver selecionado.
| Alfabeto | Bits/caractere | 64 bits | 112 bits | 128 bits |
|---|---|---|---|---|
| Só 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 e dígitos (62) | 5,9542 | 11 | 19 | 22 |
| Sem caracteres parecidos (49) | 5,6147 | 12 | 20 | 23 |
| Com símbolos seguros (74) | 6,2095 | 11 | 19 | 21 |
Excluir caracteres parecidos custa 0,3395 bit por caractere, ou 5,70%. Um caractere a mais a cada dezessete compensa essa perda, o que costuma valer a pena para tudo que uma pessoa precise ler em voz alta ou digitar de novo.
Perguntas frequentes
O que é um gerador de strings aleatórias?
Um gerador de strings aleatórias é uma ferramenta que monta uma string sorteando cada caractere de um alfabeto, como letras, dígitos e símbolos. Um bom gerador usa uma fonte aleatória criptograficamente segura e dá exatamente a mesma probabilidade a cada caractere, de modo que o resultado não pode ser previsto nem reproduzido.
Para que serve uma string aleatória?
Strings aleatórias são usadas como chaves de API, tokens de sessão, links de redefinição de senha e de verificação de e-mail, tokens CSRF, senhas, segredos de criptografia e assinatura, identificadores de banco de dados e de arquivos, códigos de cupom e de convite, e dados de teste para verificar como uma aplicação lida com uma entrada de determinado tamanho.
É seguro usar um gerador de strings aleatórias online?
É seguro quando a string é gerada no seu navegador e nunca enviada a lugar nenhum, e quando a ferramenta usa uma fonte aleatória segura. Você mesmo pode conferir neste site: abra a aba Rede nas ferramentas de desenvolvedor do navegador, clique em Gerar e nenhuma requisição aparece. Um gerador que cria o valor num servidor precisa enviá-lo para você, então ele pode ficar registrado no caminho.
Este gerador de strings aleatórias online é grátis?
Sim. É grátis, não pede cadastro, não tem limite de uso e não tem restrição para uso comercial. Funciona online no seu navegador e, depois que a página carrega, continua funcionando offline também.
Como gerar uma string aleatória com caracteres especiais?
Ative o botão !#$%. Ele adiciona doze símbolos, ! # $ % * + - = ? @ ^ _, que quase toda política de senhas aceita e que não quebram comandos de shell nem URLs. Para outro conjunto de símbolos, digite exatamente o alfabeto que você quer no campo de conjunto de caracteres personalizado, em Mais opções.
Como gerar uma string aleatória longa?
Digite o comprimento na caixa numérica ao lado do controle deslizante. O controle deslizante vai até 128, mas a caixa aceita qualquer comprimento até 4.096 caracteres. O valor de entropia se atualiza enquanto você digita, então dá para ver quando a string está longa o bastante para o uso.
Como gerar uma string alfanumérica aleatória?
Deixe os botões A-Z, a-z e 0-9 ligados e o de símbolos desligado, que é o padrão. Isso dá um alfabeto de 62 caracteres, cerca de 5,95 bits por caractere, então uma string de 24 caracteres carrega cerca de 143 bits. Para só letras, desligue o 0-9; para só números, desligue os dois botões de letras.
Posso gerar várias strings aleatórias de uma vez?
Sim. Abra Mais opções e defina uma quantidade de até 10.000. Os resultados podem aparecer um por linha, separados por vírgula, como array JSON, como lista entre aspas ou como atribuições .env, e podem ser copiados ou baixados como arquivo. Marque "Todos os resultados devem ser diferentes entre si" se o lote não puder ter repetições.
Strings aleatórias são únicas?
Não há garantia, mas uma string longa o bastante é única na prática. Repetições seguem o paradoxo do aniversário: com cerca de 143 bits, que são 24 letras e dígitos, você precisaria gerar algo em torno de 2^71 strings antes que uma repetição fique provável. Com strings curtas é diferente; um código de 6 caracteres se repete muito antes, então confira a unicidade no seu banco de dados quando a string for curta.
O que torna um gerador de strings aleatórias seguro?
Uma fonte aleatória criptograficamente segura, como crypto.getRandomValues() no navegador, e uma conversão sem viés de números aleatórios em caracteres. Um gerador baseado em Math.random() é previsível, e um que usa o operador de resto sem amostragem por rejeição deixa alguns caracteres mais prováveis que outros. Esta ferramenta não faz nenhuma das duas coisas e publica os resultados dos testes.
Como gerar uma string aleatória em Python?
Use o módulo secrets: "".join(secrets.choice(string.ascii_letters + string.digits) for _ in range(24)). secrets.choice é criptograficamente seguro e sem viés. Não use random.choice, que é um Mersenne Twister e pode ser previsto a partir da sua saída.
Como gerar uma string aleatória em Java?
Crie um único java.security.SecureRandom e chame nextInt(alphabet.length()) para cada caractere, acrescentando alphabet.charAt() a um StringBuilder. nextInt com limite não tem viés. Não use java.util.Random nem Math.random(), que são geradores previsíveis de 48 bits.
Como gerar uma string aleatória em JavaScript?
Preencha um Uint32Array com crypto.getRandomValues(), descarte os valores iguais ou maiores que o maior múltiplo do tamanho do alfabeto e indexe o alfabeto com o restante. Funciona em todos os navegadores modernos e no Node.js 19 ou posterior. A função completa está nos exemplos de código desta página. Math.random() não é seguro para isso.
Como gerar uma string aleatória em C++?
Use std::uniform_int_distribution sobre std::random_device e indexe o seu alfabeto. A distribuição não tem viés por especificação. std::random_device lê a fonte do sistema operacional nos principais compiladores, mas o padrão não garante isso, então use randombytes_uniform() da libsodium quando isso importar. Evite std::rand().
Como gerar uma string aleatória em PHP?
Chame random_int(0, strlen($alphabet) - 1) para cada caractere e acrescente o caractere dessa posição. random_int é criptograficamente seguro, sem viés e vem embutido desde o PHP 7. Não use rand(), mt_rand() nem str_shuffle() para nada secreto.
Como gerar uma string aleatória em C#?
No .NET 8 ou posterior, chame RandomNumberGenerator.GetString(alphabet, length), que é seguro e sem viés em uma linha. No .NET 6 e 7, chame RandomNumberGenerator.GetInt32(alphabet.Length) para cada caractere. System.Random não serve para segredos.
Como gerar uma string aleatória em PowerShell?
No PowerShell 7.4 ou posterior, chame [System.Security.Cryptography.RandomNumberGenerator]::GetString($chars, 24). No Windows PowerShell 5.1, que não tem esse método, acrescente $chars[(Get-Random -Maximum $chars.Length)] uma vez por caractere. Get-Random usa o gerador criptográfico do sistema, a menos que você passe -SetSeed. Evite Get-Random -Count, que nunca repete um caractere.
Como gerar uma string aleatória em Node.js?
Para uma string hexadecimal ou segura para URL, use crypto.randomBytes(16).toString("hex") ou crypto.randomBytes(18).toString("base64url"). Para um alfabeto personalizado, escolha cada caractere com crypto.randomInt(alphabet.length), que é seguro e sem viés. Não monte segredos com Math.random().
Como gerar uma string aleatória no Linux ou no Bash?
Execute LC_ALL=C tr -dc "A-Za-z0-9" < /dev/urandom | head -c 24 para 24 letras e dígitos, ou openssl rand -hex 16 para uma string hexadecimal de 32 caracteres. Os dois leem a fonte aleatória do kernel. Evite $RANDOM, que é um valor de 15 bits vindo de um gerador não criptográfico.
Como gerar uma string aleatória em Go?
Use crypto/rand. A partir do Go 1.24, rand.Text() retorna uma string Base32 de 26 caracteres com pelo menos 128 bits de aleatoriedade. Para o seu próprio alfabeto, escolha cada caractere com rand.Int(rand.Reader, big.NewInt(int64(len(alphabet)))). Nunca use math/rand para segredos.
Como gerar uma string aleatória no Excel?
No Excel 365, =TEXTJOIN("",TRUE,CHAR(RANDARRAY(10,1,65,90,TRUE))) gera 10 letras maiúsculas aleatórias, que mudam sempre que a planilha é recalculada. No Excel em português, a mesma fórmula costuma ser =UNIRTEXTO("";VERDADEIRO;CARACT(MATRIZALEATÓRIA(10;1;65;90;VERDADEIRO))). As funções aleatórias do Excel não são criptograficamente seguras, então use isso só para dados de teste e gere senhas ou chaves com uma ferramenta segura.
Alguma coisa que eu gero é enviada a um servidor?
Não. A geração acontece inteiramente no seu navegador com a Web Crypto API. Não existe servidor para onde enviar nada, e você mesmo pode confirmar: abra as ferramentas de desenvolvedor do navegador, vá até a aba Rede e clique em Gerar. Nada aparece.
Qual é a diferença em relação a usar Math.random()?
Math.random() não é criptograficamente seguro. O V8 o implementa com xorshift128+, um gerador não criptográfico de 128 bits, e a especificação do JavaScript não exige que a saída seja imprevisível. Trabalhos publicados mostram que alguém que observe algumas saídas consegue recuperar o estado interno e reproduzir todos os valores passados e futuros. Esta ferramenta usa crypto.getRandomValues(), que obtém os dados do CSPRNG do sistema operacional.
O que é viés do módulo, e esta ferramenta tem esse problema?
Reduzir um número aleatório com o operador de resto puxa o resultado para o começo do alfabeto. Mapear um byte para 62 caracteres dá 256 = 4x62 + 8, então os oito primeiros caracteres ficam 1,25 vez mais prováveis que o restante. Esta ferramenta elimina isso com amostragem por rejeição: os sorteios que caem no último ciclo incompleto são descartados em vez de reaproveitados.
Por que a entropia cai quando exijo todos os tipos de caracteres?
Porque ela deve cair. Exigir pelo menos um dígito proíbe todas as strings sem dígito, então há menos resultados possíveis e a entropia real fica abaixo de comprimento x log2(tamanho do alfabeto). A maioria dos geradores continua mostrando o número mais alto. Este conta as strings válidas por inclusão-exclusão e mostra o valor real, com o valor sem restrições entre parênteses para você ver o custo.
Qual deve ser o comprimento de uma string aleatória?
Depende do que ela protege. Para um valor que um atacante só consegue adivinhar online, contra um serviço que limita requisições, 64 bits é folgado. Para um segredo que pode ser capturado e atacado offline, mire em 112 bits ou mais; 19 caracteres alfanuméricos chegam a 113 bits. Para senhas, o NIST SP 800-63B exige no mínimo 15 caracteres e desaconselha expressamente regras de composição.
Posso usar isto para senhas, chaves de API e tokens de sessão?
Sim. A fonte de aleatoriedade é a mesma que o seu sistema operacional oferece a qualquer aplicação, e a conversão em caracteres não tem viés. O que a ferramenta não consegue é proteger o valor depois que ele sai desta página, então trate o resultado como trataria qualquer outro segredo.
Velocidade
Gerar 10.000 strings de 32 caracteres leva 17 ms. Lotes grandes são produzidos em partes, com a thread principal liberada entre uma e outra, então a página continua respondendo e a execução pode ser cancelada. Três dos geradores que aparecem hoje na primeira página do Google não têm nenhum limite de quantidade e travam a aba.