Entropia de senhas: como medir e maximizar a força das suas senhas

Provavelmente já disseram que uma “senha forte” precisa de letras maiúsculas, números e caracteres especiais. Mas P@$$w0rd! cumpre todas essas regras — e pode ser quebrada em menos de um segundo.

A verdadeira medida da força de uma senha não são os caracteres que você usa. É a entropia: um conceito da teoria da informação que quantifica o quão imprevisível sua senha realmente é.

Neste guia você aprenderá exatamente como funciona a entropia das senhas, como calculá-la e como gerar senhas que são genuinamente difíceis de quebrar.

O que é a entropia de uma senha?

A entropia de uma senha mede o quão imprevisível ela é, expressa em bits. Cada bit adicional de entropia duplica o número de tentativas que um atacante precisa para quebrá-la por força bruta.

Pense nisso como dados. Um dado de 6 faces tem cerca de 2,6 bits de entropia por lançamento — existem apenas 6 resultados possíveis. Um dado de 20 faces tem cerca de 4,3 bits — mais faces significa mais incerteza.

As senhas funcionam da mesma forma: mais caracteres possíveis (“dados” maiores) e mais caracteres na senha (mais “lançamentos”) aumentam a entropia.

Por isso a entropia é uma medida melhor do que regras de complexidade. Uma senha pode parecer complexa (Tr0ub4dor&3) mas ter pouca entropia porque segue padrões previsíveis. Enquanto isso, uma frase aparentemente simples (cavalo correto bateria grampo) pode ter alta entropia porque é extraída de um grande conjunto de possibilidades.

A fórmula: como calcular a entropia de uma senha

A fórmula é simples:

E = L × log₂(R)

Onde:

E = entropia em bits
L = comprimento da senha (número de caracteres)
R = tamanho do conjunto (número de caracteres possíveis por posição)

Tamanhos de conjuntos de caracteres

Tipo de caractere	Tamanho do conjunto (R)	Bits por caractere
Apenas minúsculas (a-z)	26	4,70
Minúsculas + dígitos	36	5,17
Maiúsculas + minúsculas + dígitos	62	5,95
ASCII imprimível completo	94	6,55
Lista de palavras Diceware	7.776	12,92 por palavra

Calcule em código

// Calcular a entropia de uma senha em JavaScript
const entropy = (length, poolSize) =>
  length * Math.log2(poolSize);

entropy(8, 26);   // → 37.60 bits (apenas minúsculas)
entropy(12, 62);  // → 71.45 bits (alfanumérico)
entropy(16, 94);  // → 104.87 bits (charset completo)

import math

def entropy(length: int, pool_size: int) -> float:
    return length * math.log2(pool_size)

entropy(8, 26)   # → 37.60 bits
entropy(12, 62)  # → 71.45 bits
entropy(16, 94)  # → 104.87 bits

Importante: esta fórmula assume que cada caractere é escolhido de forma uniformemente aleatória. Se uma pessoa escolhe a senha usando padrões ou palavras do dicionário, a entropia real é muito menor que o máximo teórico.

Quanta entropia é suficiente?

A resposta depende do que você está protegendo e da velocidade com que um atacante pode adivinhar.

As GPUs modernas podem testar mais de 10¹² (um trilhão) de hashes de senhas por segundo contra algoritmos rápidos como MD5. Veja o que isso significa na prática:

Entropia (bits)	Força	Tempo de quebra a 10¹² tentativas/s	Recomendado para
< 40	Fraca	Menos de 1 segundo	Nunca usar
40–59	Regular	Segundos a horas	Contas descartáveis
60–79	Forte	Dias a séculos	Contas regulares
80–99	Muito forte	Milênios ou mais	Email, banco
100+	Extrema	Além da morte térmica do universo	Chaves de criptografia, senhas mestras

Uma senha de 16 caracteres usando o conjunto ASCII imprimível completo dá cerca de 105 bits de entropia — bem dentro da faixa “extrema”. Você pode gerar uma instantaneamente com nosso Gerador de Senhas Aleatórias, que mostra análise de entropia em tempo real para cada senha.

O que o NIST diz (atualização 2024)

O NIST SP 800-63B, atualizado em 2024, fez mudanças significativas nas diretrizes de senhas:

Eliminou as regras de complexidade obrigatórias (sem mais caracteres especiais forçados)
Eliminou as trocas de senha periódicas obrigatórias
Aumenta o mínimo para 15 caracteres (contra 8 em versões anteriores)
Enfatiza a verificação contra senhas vazadas conhecidas
Favorece o comprimento e a aleatoriedade sobre a complexidade

Essas mudanças refletem o que a matemática da entropia sempre demonstrou: o comprimento e a aleatoriedade importam mais que a variedade de caracteres.

Por que o comprimento supera a complexidade

Compare estas duas abordagens. Considere duas formas de aumentar a entropia de uma senha de 12 caracteres:

Opção A — Manter 12 caracteres, mudar de alfanumérico (62) para ASCII completo (94):

12 × log₂(94) - 12 × log₂(62) = 78,66 - 71,45 = +7,21 bits

Opção B — Manter alfanumérico (62), adicionar um caractere a mais (12 → 13):

13 × log₂(62) - 12 × log₂(62) = 77,40 - 71,45 = +5,95 bits

Adicionar um único caractere dá quase tanta entropia quanto mudar para um conjunto de caracteres muito maior. Adicione dois caracteres e terá superado.

Agora considere P@$$w0rd! (9 caracteres). Usa o conjunto ASCII completo mas é curta demais. Pior ainda, segue o padrão previsível de “leet speak” que os ataques de dicionário já contemplam, então sua entropia efetiva está muito abaixo dos 59 bits teóricos.

A conclusão: para senhas verdadeiramente aleatórias, adicionar comprimento é mais eficiente do que adicionar tipos de caracteres. Mas o verdadeiro inimigo é a previsibilidade, não a brevidade.

Frase-senha vs senha aleatória

Dimensão	Senha aleatória	Frase-senha (Diceware)
Exemplo	`kX#9mP$2vL!nQ7wR`	`cavalo correto bateria grampo`
Bits por unidade	6,55 por caractere	12,92 por palavra
Comprimento para ~78 bits	12 caracteres	6 palavras
Memorabilidade	Difícil	Boa
Digitação no celular	Dolorosa	Fácil
Melhor para	Entradas do gerenciador de senhas	Senhas mestras, logins memorizados

Como funciona o Diceware

O Diceware usa uma lista de palavras de 7.776 entradas (6⁵ = 7.776). Você lança cinco dados para selecionar cada palavra, dando exatamente 12,92 bits de entropia por palavra.

Quatro palavras dão ~51 bits; seis palavras dão ~77 bits.

Qual você deve usar?

Para senhas armazenadas em um gerenciador: use senhas aleatórias de 16 ou mais caracteres com conjuntos de caracteres completos. Você nunca as digita manualmente, então a memorabilidade não importa. Nosso Gerador de Senhas Aleatórias pode gerar até 50 em lote.
Para sua senha mestra: use uma frase Diceware de 5-6 palavras. É memorizável o suficiente para digitar diariamente enquanto fornece 64-77 bits de entropia.
Para chaves de API e tokens: use openssl rand ou crypto.randomBytes() para máxima entropia sem requisito de memorização humana.

Entropia na prática: ferramentas e código para desenvolvedores

Aqui estão as formas mais comuns que os desenvolvedores geram segredos de alta entropia:

Navegador (Web Crypto API)

// Geração de senhas com segurança criptográfica
function generatePassword(length, charset) {
  const array = new Uint32Array(length);
  crypto.getRandomValues(array);
  return Array.from(array, v => charset[v % charset.length]).join('');
}

const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
generatePassword(16, chars);
// → 'kX#9mP$2vL!nQ7wR' (aleatório cada vez)

Node.js

const crypto = require('crypto');
const token = crypto.randomBytes(32).toString('base64url');
// → 'Ql2Hj8xK9mNp3rVw5tYz7uBa0cEf4gIk' (43 caracteres, 256 bits)

Python

import secrets
token = secrets.token_urlsafe(32)  # 256 bits de entropia
password = secrets.token_hex(16)    # 128 bits, formato hexadecimal

Linha de Comando

# 192 bits de entropia, codificado em base64
openssl rand -base64 24

# 256 bits, codificado em hexadecimal
openssl rand -hex 32

Comparação de Entropia por Método

Método	Comprimento da saída	Entropia (bits)
UUID v4	36 caracteres	122
`openssl rand -base64 24`	32 caracteres	192
16 caracteres ASCII completo	16 caracteres	105
6 palavras Diceware	~30 caracteres	78
4 palavras Diceware	~20 caracteres	52

Nunca use Math.random() para nada relacionado à segurança. É um PRNG não criptográfico — a saída é previsível se um atacante conhece a semente. Use sempre crypto.getRandomValues() no navegador ou crypto.randomBytes() no Node.js.

Armazenamento de senhas: por que a entropia sozinha não é suficiente

Mesmo uma senha de 128 bits não vale nada se o servidor a armazena como um hash MD5 simples. Quando um banco de dados vaza, os atacantes podem testar trilhões de hashes MD5 por segundo em uma única GPU.

É aí que entram os algoritmos de hashing lento. Eles tornam cada tentativa deliberadamente custosa:

Algoritmo	Velocidade na GPU	Desaceleração efetiva
MD5	~10 bilhões/s	Base (não usar)
SHA-256	~5 bilhões/s	~2× mais lento
bcrypt (cost=12)	~5/s	~2 bilhões× mais lento
argon2id	~2/s	~5 bilhões× mais lento

O parâmetro de custo do bcrypt é especialmente elegante: cada incremento duplica o trabalho necessário. Um fator de custo de 12 significa 2¹² = 4.096 rodadas de hashing. Isso adiciona efetivamente 12 bits de “entropia de armazenamento” acima da entropia própria da senha.

O modelo de dupla proteção: senhas de alta entropia protegem contra a força bruta offline, enquanto o hashing lento protege contra os vazamentos de banco de dados. Você precisa de ambos.

Para mais informações sobre algoritmos hash, consulte nossa comparação de MD5 vs SHA-256 e experimente o Gerador de Hash MD5 para explorar como diferentes algoritmos produzem saídas distintas.

Mitos comuns sobre senhas desmascarados

”Troque sua senha a cada 90 dias”

As diretrizes do NIST de 2024 recomendam explicitamente não fazer trocas periódicas obrigatórias. As rotações frequentes levam os usuários a escolher senhas mais fracas e previsíveis — adicionando um número no final, rotacionando entre um pequeno conjunto. Troque as senhas apenas quando tiver motivos para acreditar que foram comprometidas.

”a→@, e→3 a torna mais forte”

As substituições de leet speak são dos primeiros padrões que os ataques de dicionário verificam. Substituir a por @ em senha adiciona praticamente zero entropia porque os atacantes já esperam isso.

A verdadeira aleatoriedade — não as substituições inteligentes — é o que aumenta a entropia.

”8 caracteres com símbolos é suficiente”

Mesmo com o conjunto ASCII completo de 94 caracteres, 8 caracteres dão apenas 52 bits de entropia. A 10¹² tentativas por segundo, isso é quebrado em cerca de 75 minutos.

Use um mínimo de 12 caracteres, 16 ou mais para contas importantes.

”Quanto mais complexa parece, mais segura é”

A complexidade visual e a entropia são coisas diferentes. Tr0ub4dor&3 parece complexa mas segue um padrão previsível de palavra-base-mais-substituições. mfYq8kL2nR parece mais simples mas tem maior entropia porque é verdadeiramente aleatória.

Para mais informações sobre como construir uma estratégia de segurança integral, consulte Segurança Web Essencial.

Perguntas frequentes

Quantos bits de entropia são considerados seguros?

Para a maioria das contas online, 60-80 bits proporcionam uma proteção forte. Para alvos de alto valor como senhas mestras ou chaves de criptografia, mire em 100 ou mais bits. Cada bit adicional duplica o esforço necessário pelo atacante.

Adicionar caracteres especiais sempre aumenta a entropia?

Apenas se os caracteres são escolhidos aleatoriamente do conjunto completo. As substituições previsíveis como @ por a ou ! no final adicionam praticamente zero entropia porque os atacantes já levam em conta esses padrões em seus dicionários.

Qual é a entropia de uma frase Diceware de 4 palavras?

Usando a lista Diceware padrão de 7.776 palavras, cada palavra contribui com 12,92 bits. Quatro palavras dão aproximadamente 51,7 bits — adequado para usos de baixa segurança. Para contas importantes, use 5-6 palavras (64-78 bits).

O Math.random() é seguro para gerar senhas?

Não. Math.random() é um gerador de números pseudoaleatórios que não é criptograficamente seguro. Use crypto.getRandomValues() no navegador ou crypto.randomBytes() no Node.js para a geração aleatória relacionada à segurança.

Como o fator de custo do bcrypt afeta a segurança?

Cada incremento do fator de custo do bcrypt duplica a computação necessária para fazer hash (e portanto para quebrar por força bruta) uma senha. Um custo de 12 significa 2¹² = 4.096 iterações, adicionando efetivamente 12 bits de dificuldade acima da entropia intrínseca da senha.

O que mudou nas diretrizes de senhas do NIST de 2024?

O NIST SP 800-63B eliminou os requisitos de complexidade obrigatórios (caracteres especiais forçados, maiúsculas e minúsculas misturadas) e a rotação periódica de senhas. A nova diretriz favorece senhas mais longas (15 ou mais caracteres são recomendados), a verificação contra bancos de dados de senhas vazadas e permite todos os caracteres imprimíveis incluindo espaços.

Conclusões principais

Entropia = L × log₂(R) — cada bit extra duplica o número de tentativas necessárias
Comprimento > complexidade — adicionar um caractere é mais efetivo do que ampliar o conjunto de caracteres
Use as APIs de cripto — crypto.getRandomValues() ou crypto.randomBytes(), nunca Math.random()
Gerenciador de senhas + geração aleatória é a melhor prática para a maioria das pessoas
O lado do servidor também importa — use bcrypt ou argon2, nunca armazene senhas com MD5

Pronto para gerar uma senha de alta entropia? Experimente nosso Gerador de Senhas Aleatórias — mostra análise de entropia em tempo real para cada senha que você cria.

Entropia de Senhas: Calcule e Fortaleça Suas Senhas