Como gerar um número realmente aleatório (e qual tipo você de fato precisa)

A resposta curta

Escolha o gerador pelo que custa se alguém adivinhar o seu número. Se adivinhar custa alguma coisa — uma conta, uma chave, um sorteio justo —, use o gerador criptograficamente seguro da sua plataforma: crypto.getRandomValues no navegador, o módulo secrets do Python, ou a fonte de entropia do sistema operacional na qual os dois se apoiam. Se adivinar não custa nada — um lançamento de dado num jogo, uma execução de Monte Carlo —, um gerador pseudaleatório comum com semente é mais rápido e reproduzível, que é o que você quer ali.

Duas regras pegam a maioria dos erros reais. Nunca use Math.random() nem o rand() do C para criar um segredo. E nunca reduza um valor aleatório mais amplo ao seu intervalo com o operador resto e considere o trabalho pronto, porque isso introduz viés de módulo — a razão pela qual a ferramenta vinculada sorteia de novo em vez de confiar num único resto.

• Segredo, token, chave, ou um sorteio que alguém possa contestar: o CSPRNG da plataforma, sempre.
• Simulação, amostragem, ou qualquer coisa que você queira rodar duas vezes com o mesmo resultado: um gerador com semente.
• Aleatoriedade física de verdade: hardware ou um serviço de entropia, algo inatingível de uma página web.
• A ferramenta vinculada é o caso do navegador: inteiros uniformes num intervalo inclusivo, a partir do CSPRNG do sistema operacional, com amostragem por rejeição, até 500 por execução.

Três coisas diferentes chamadas de aleatório

Uma palavra cobre três mecanismos com três garantias diferentes. Leia-os como uma escada de imprevisibilidade.

A aleatoriedade de verdade vem da física

Um gerador de números verdadeiramente aleatórios amostra um processo físico cujo resultado não é decidido por nada que você possa medir: ruído térmico num resistor, o instante do decaimento radioativo, ruído atmosférico captado por um receptor de rádio, jitter de oscilador. Existe hardware para isso, os fabricantes de chips expõem isso como instrução ou periférico, e serviços públicos transmitem ruído atmosférico amostrado para quem pedir. O resultado é imprevisível em princípio — nenhuma quantidade de computação o recupera. Mas as fontes brutas não são uniformes: a eletrônica deixa um pouco mais de um símbolo do que do outro, então os geradores de hardware condicionam as amostras por um extrator de aleatoriedade antes que alguém chame a saída de aleatória.

Pseudoaleatoriedade criptograficamente segura

Um CSPRNG é um algoritmo determinístico que mantém um estado interno secreto, semeado uma vez com entropia real e depois avançado por computação. O sistema operacional obtém essa semente de fontes que pode observar — temporização de interrupções, intervalos de chegada do teclado e do mouse, ruído de hardware quando um driver o expõe — num pool protegido pelo kernel. Cada chamada a crypto.getRandomValues retira desse pool, ou de um gerador que o sistema operacional semeia a partir dele.

A garantia é prática e não filosófica: um atacante que observa um longo trecho da saída ainda não consegue descobrir o estado, então não pode prever o próximo valor nem reconstruir os anteriores. Essa é a propriedade que chaves e tokens precisam, e é por isso que este nível, e não o da física, é o que o software do dia a dia alcança.

Pseudoaleatoriedade comum

Um gerador simples é a mesma construção com o requisito de segurança removido: uma recorrência determinística sobre um estado fixo, escolhida por velocidade e qualidade estatística. O módulo random do Python implementa o Mersenne Twister, que distribui lindamente e é inteiramente previsível quando um observador junta saídas consecutivas suficientes para resolver o seu estado.

Essas são as ferramentas certas para simulação: rápidas, testáveis contra baterias estatísticas e configuráveis — mesma semente, mesma corrente. Isso é um recurso num experimento de Monte Carlo e um desastre num token de sessão, e é a distinção que as pessoas mais têm ao contrário.

O que um navegador pode honestamente te dar

Primeiro, sem rodeios: uma página web não pode colher entropia física. O JavaScript não pode amostrar uma fonte de ruído, não tem instrução para ler aleatoriedade de hardware e não pode medir a temporização de elétrons. Tudo que um navegador entrega veio de um algoritmo cujo estado foi semeado pelo sistema operacional.

O que um navegador pode te dar é o CSPRNG do sistema operacional, embrulhado como crypto.getRandomValues, que preenche um array tipado com bytes ou palavras de 32 bits do pool do kernel. O Web Crypto expõe exatamente uma primitiva e ela é a criptográfica, então não há uma chamada mais fraca em que esbarrar, e a página da ferramenta vinculada a descreve como a mesma primitiva usada para senhas e chaves de criptografia.

Para todo propósito de quem lê esta página, a resposta com CSPRNG é a resposta certa. Um sorteio, um identificador de sessão, uma senha gerada no seu notebook: nenhum precisa de decaimento radioativo, e todos são servidos por um gerador que um atacante não pode prever. Páginas que anunciam “aleatoriedade verdadeira” a partir de uma aba estão sendo descuidadas ou desonestas; a afirmação precisa é “imprevisível para quem ainda não comprometeu o seu sistema operacional”, e isso basta.

Por que Math.random() não é para segredos

A objeção é mecânica. Math.random() é uma função determinística de um estado interno: o motor mantém um bloco de números, aplica uma recorrência fixa para avançá-los, devolve um resultado formatado e não consulta nada externo no meio. A sequência está implícita no estado, então a única pergunta é se um observador consegue encontrá-lo.

Por muito tempo a resposta foi confortavelmente sim. Os geradores usados pelos navegadores eram projetos estatísticos de estado pequeno cuja saída vaza estrutura: um punhado de valores consecutivos basta para montar equações cuja solução é o estado. Com o estado você avança a recorrência para prever cada sorteio posterior e para trás para recuperar cada anterior — o modo de falha documentado que fez os navegadores abandonarem esses projetos.

Há uma segunda camada. Você nunca vê o estado, então não pode conferir se o estado chegou a ser imprevisível, e um gerador semeado de forma preguiçosa a partir de um relógio grosseiro tem um espaço de busca que um atacante enumera.

O crypto.getRandomValues é construído ao contrário: observar a saída não ajuda a reconstruir o estado, então adivinhar o seu número custa um trabalho proporcional ao intervalo e não a algumas amostras.

O viés de módulo, com números que você pode conferir

A parte que muitos artigos erram ou pulam é aritmética que você pode conferir à mão. Suponha que sua fonte emita um byte uniforme — um entre 256 valores, 0 até 255, cada um com probabilidade 1 em 256 — e você queira um dígito uniforme de 0 a 9. A linha de código tentadora é o resto da divisão por 10.

Conte quantos valores de byte caem em cada dígito. 256 dividido por 10 é 25 com resto 6; exatamente, 256 = 25 × 10 + 6. Cada dígito recebe 25 valores e sobram 6 no topo do intervalo, e esses caem nos dígitos mais baixos: os resultados 0 até 5 recebem 26 valores de suporte cada um, os resultados 6 até 9 recebem 25. O total fecha, já que 6 × 26 é 156, 4 × 25 é 100 e 156 + 100 = 256.

Um dígito favorecido tem probabilidade 26/256, que é 0.1015625; um dígito azarado 25/256, que é 0.09765625; um sorteio justo seria 0.1 para cada. Os dígitos favorecidos são 26/25 vezes mais prováveis que os outros, e 26/25 é exatamente 1.04 — quatro por cento mais provável.

Quando o viés deixa de ser acadêmico

Quatro por cento é leve. O viés fica sério quando seu intervalo é uma fração grande da fonte, porque então há poucos passes completos e o bloco que sobra é proporcionalmente enorme. O gerador vinculado sorteia palavras de 32 bits, então sua fonte tem 2^32 valores, que são 4,294,967,296.

Caso amigável: um dado de seis faces, mínimo 1 e máximo 6, tamanho de intervalo 6. Divisão: 4,294,967,296 = 6 × 715,827,882 + 4. Um resto puro favorece quatro faces — as faces 1 até 4 vêm de 715,827,883 entradas cada uma, as faces 5 e 6 de 715,827,882. Cerca de uma parte em um bilhão, que é por que nenhum jogo de tabuleiro foi viciado assim.

Caso adversarial: um índice de loteria de 0 a 2,147,483,646, um intervalo de 2^31 − 1 valores. O dobro desse intervalo é 4,294,967,294, que é 2 a menos que 4,294,967,296, então um resto dá aos dois primeiros bilhetes 3 chances cada e a todos os outros 2 — uma vantagem de 50%, já que 3/2 é exatamente 1.5.

Amostragem por rejeição: a correção

Descarte o resto desajeitado em vez de dobrá-lo. No caso do byte, 250 = 25 × 10 divide exatamente, então mantenha apenas as entradas 0 até 249 e sorteie de novo sempre que tirar 250 ou mais. Cada entrada aceita mapeia então para um dígito por exatamente 25 valores, e 25/250 é exatamente 0.1. O custo é uma chance de novo sorteio de 6/256 por tentativa, que é insignificante e termina com certeza.

O gerador vinculado faz o mesmo em 32 bits. Ele calcula limit = Math.floor(4294967296 / range) * range — o maior múltiplo do seu intervalo que cabe na fonte —, sorteia uma palavra, sorteia de novo enquanto o valor for maior ou igual a esse limite, e devolve min + (x % range). Para o dado, limit é 6 × 715,827,882, que é 4,294,967,292, então exatamente as quatro entradas mais altas são rejeitadas, e a chance de novo sorteio é 4 em 4,294,967,296, ou 1 em 1,073,741,824. Condicionado à aceitação, cada face tem 715,827,882 entradas de suporte e 6 × 715,827,882 = 4,294,967,292, então cada face é exatamente um sexto. O próprio texto da ferramenta diz isso sem a álgebra: um valor sorteado fora do maior múltiplo do seu intervalo que cabe em 32 bits é descartado e sorteado de novo, e isso elimina o viés de módulo.

Uniforme, com semente, reproduzível: três ideias separadas

“Número aleatório” também esconde uma pergunta de forma: a distribuição, a semente e se uma execução pode ser repetida.

Uniformidade é uma propriedade da distribuição

Um sorteio uniforme significa que cada valor do seu intervalo teve a mesma chance — o dado, o sorteio, o índice aleatório. Um sorteio não uniforme molda as chances deliberadamente: ruído de medição normal, lacunas exponenciais entre chegadas, amostragem ponderada em que o item A é três vezes mais provável que o item B. A simulação gasta a maior parte do seu esforço no caso não uniforme, e a técnica padrão é partir de uma corrente uniforme e transformá-la.

A ferramenta vinculada é só uniforme sobre um intervalo de inteiros: uma curva de sino, uma escolha ponderada ou um decimal são outro trabalho.

O que uma semente realmente é

A semente é o estado inicial de um gerador determinístico. Mesmo gerador, mesma semente, mesma sequência de saídas, para sempre. Definir uma semente não adiciona aleatoriedade; ela fixa o ponto de partida de uma computação para que a execução possa ser repetida.

É por isso que geradores com semente são queridos na simulação: um colega repete seu experimento e obtém os seus números, um artigo publica a semente para revisão. A previsibilidade é o objetivo, e um CSPRNG sem semente atrapalha porque você não consegue mostrar a sequência por trás da sua conclusão.

Por que reproduzibilidade é o objetivo errado para segredos

Vire essa propriedade ao contrário e ela é a vulnerabilidade: um gerador de segredos reproduzível é um gerador adivinhável. Quem souber ou adivinhar a semente regenera cada valor que você emitiu, em ordem, e um segredo que qualquer um pode regenerar não é um segredo.

Por isso as ferramentas que cunham chaves e tokens se recusam a expor sementes. O gerador vinculado não tem entrada de semente nem como repetir uma execução; cada sorteio sai fresco do pool do sistema operacional, e o estado vive no kernel e não na página.

Em Python, C++, JavaScript e MATLAB

Cada variante de linguagem desta busca tem a mesma resposta sob a sintaxe: use o gerador criptograficamente seguro da plataforma, não o de brinquedo. Em duas dessas linguagens a biblioteca padrão não fornece um por completo.

O Python divide o trabalho deliberadamente. random é o módulo pseudaleatório — baseado em Mersenne Twister, bom para jogos e simulação, documentado como inadequado para segurança. Para segredos use o módulo secrets: secrets.randbelow(n) devolve um valor uniforme de 0 até n−1 a partir da fonte de entropia do sistema operacional, e secrets.token_urlsafe cobre tokens. Para uma simulação reproduzível, semeie com random.seed(1234) e fique no random.

O C++ não tem CSPRNG na biblioteca padrão, que é a resposta honesta ao autocompletado. std::random_device é a alça prevista sobre entropia não determinística e a coisa certa com que semear um motor, mas seu comportamento é definido pela implementação: em algumas cadeias de ferramentas ele passa direto para a fonte do sistema operacional, em outras cai num motor pseudaleatório com semente, pode bloquear enquanto o pool do kernel se enche no início do boot, e a uniformidade de resultados individuais não é garantida. std::mt19937 é explicitamente um gerador estatístico, e o rand() legado do C não é uniforme sob um resto nem imprevisível. Quando importar de verdade, chame a API de entropia da própria plataforma ou uma biblioteca de criptografia auditada.

JavaScript no navegador é uma chamada: crypto.getRandomValues num array tipado, que é o que a ferramenta vinculada usa, e esse mesmo global existe no Node e no Deno. Para um inteiro sem viés, combine-o com amostragem por rejeição em vez de multiplicar um float.

O MATLAB merece uma linha porque quem o busca pede “um número real aleatório” e “números realmente aleatórios”. Suas funções de uso geral — rand, randi, randn, com rng controlando a semente — são pseudaleatórias por design: determinísticas, semeáveis, estatisticamente excelentes, feitas para trabalho numérico reproduzível. Uma fonte de entropia real é outra coisa, e conseguir uma significa recorrer a um recurso do sistema operacional ou a um serviço externo.

A regra que cobre as quatro: o CSPRNG da plataforma quando adivinhar te prejudica, o gerador estatístico com semente quando adivinhar te ajuda. Não há meio-termo.

Para que você precisa de aleatoriedade, e o que quebra quando ela é fraca

Chaves, senhas e qualquer coisa derivada delas. Aqui a fraqueza é aritmética: um atacante enumera o espaço plausível, e cada sorteio uniforme independente de m valores adiciona log2(m) bits — um byte adiciona 8 bits porque 2^8 = 256, enquanto dez valores adicionam um pouco mais de 3, já que log2(10) é cerca de 3.32. Quatro dígitos são menos de 14 bits, que são dez mil tentativas para enumerar; trinta e dois bytes são 256 bits, que ninguém enumera. Um gerador com estado reconstruível, ou uma semente tirada de um relógio, colapsa esse número ao tamanho da semente.

Tokens: identificadores de sessão, links de redefinição, chaves de API. Duas formas de perder. A previsibilidade deixa um atacante forjar o próximo token em vez de encontrar o seu. A colisão é mais sutil: tokens vêm de um pool finito, então emitir muitos curtos acaba dando a dois usuários a mesma string, e a sessão autenticada de alguém vira a de outra pessoa. Dimensione o token para o volume que você emite e sorteie-o de um CSPRNG.

Sorteios e loterias — rifas, seleção de alunos, amostragem de auditoria. O requisito é defensabilidade e não sigilo: depois alguém pergunta se o processo poderia ter favorecido um participante, e você precisa de uma resposta. O viés de módulo é o jeito clássico de um sorteio bem-intencionado ficar injusto, e a previsibilidade é o jeito de ele ser viciado de antemão. Use o gerador criptográfico com amostragem por rejeição, guarde a lista de inscritos e a saída, e não deixe que o vencedor tenha escrito o script.

Amostragem e simulação — integração de Monte Carlo, bootstrap, tráfego de teste de carga. Aqui você quer qualidade estatística e reproduzibilidade, e um CSPRNG está errado nas duas direções: mais lento e incapaz de repetir uma execução. Use um gerador estatístico com semente e registre a semente. Para aleatoriedade puramente cosmética, nada quebra.

Modos de falha comuns

Quatro padrões explicam a maior parte da aleatoriedade quebrada em código de verdade, e os quatro parecem normais num teste rápido.

Inventar o próprio embaralhamento. A versão tentadora — para cada posição, trocar com um elemento escolhido de qualquer lugar do array — é enviesada, tornando algumas ordens mais prováveis que outras. A passagem Fisher–Yates correta troca cada elemento com uma posição sorteada uniformemente nela ou depois, e se a ordem protege alguma coisa, esses sorteios precisam do CSPRNG. A versão descuidada não pode ser ajustada até a correção: escolher um índice para cada uma das n posições produz n^n caminhos igualmente prováveis, que se dividem exatamente entre as n! ordens só se n! divide n^n, e para um baralho de 52 cartas não divide — 52^52 tem apenas 2 e 13 como fatores primos, enquanto 52! inclui 3.

rand() % n, ou qualquer resto sobre uma fonte que não divide. Os resultados baixos acumulam as sobras, a distorção é invisível no uso casual, e ela é decisiva quando o intervalo é uma fração grande da fonte. A amostragem por rejeição é a correção, não uma fonte mais ampla — 10 também não divide 65,536.

Semear pelo relógio. Uma semente de marca de tempo deixa um espaço de busca que você pode enumerar: um atacante que sabe que seu token apareceu durante um dado minuto tenta as cerca de 60 sementes daquele minuto e adianta cada gerador. Semear pelo relógio também colide: dois processos iniciados juntos recebem a mesma semente e emitem correntes idênticas.

Reutilizar uma semente, ou uma corrente para dois propósitos. Mesma semente, mesma sequência, então dois componentes semeados igual produzem valores que batem, e recuperar um recupera o outro. Sorteie de forma independente, por propósito, do CSPRNG, e se o seu design precisa que dois valores difiram, verifique que eles difiram em vez de esperar que sorteios independentes não se encontrem.

O gerador vinculado: o que ele faz e onde ele para

A ferramenta por trás deste botão é o caso do navegador, construída como as seções acima defendem. Você define um mínimo e um máximo inclusivos e uma contagem de inteiros; ela sorteia cada valor com crypto.getRandomValues num Uint32Array e aplica amostragem por rejeição — limit = Math.floor(4294967296 / range) * range, sorteiar de novo enquanto a palavra for maior ou igual a esse limite — e então devolve min + (x % range). Na saída, nenhum valor é mais provável pela posição que ocupa no seu intervalo.

Os controles são pequenos de propósito. As extremidades são inclusivas, então 1 a 6 é um dado, e máximo igual a mínimo é permitido. Negativos funcionam, e as caixas das extremidades são texto sem limite. Os resultados saem um por linha ou separados por vírgulas, e um botão Copiar os coloca na área de transferência. Um modo opcional sem duplicados mantém cada valor num conjunto e sorteia de novo até completá-lo, e dá erro quando você pede mais valores do que o intervalo contém. O que ele não faz é a parte honesta.

• Só inteiros — nada de decimais ou floats; um real uniforme num intervalo é outra ferramenta.
• Só uniforme — nada ponderado, normal ou exponencial.
• Até 500 números por execução; o próprio conselho da ferramenta para precisar de mais é rodá-la algumas vezes e juntar as saídas.
• Sem controle de semente e sem execuções reproduzíveis, de propósito — uma execução que você pode repetir é uma execução que outra pessoa também pode repetir.
• Sem listas de exclusão; você não pode sortear de 1 a 100 pulando os múltiplos de 5.
• Intervalos que abrangem mais de 2^32 valores não são suportados, já que o limite de rejeição assume uma fonte de 32 bits.
• Nada é armazenado, exportado ou baixado: feche a aba e os números somem.
• A lógica de geração em si não faz nenhuma requisição — só criptografia, DOM e APIs de área de transferência —, mas o site carrega scripts de terceiros, então a página não é livre de rede e não diz ser.

Perguntas frequentes