Introdução: Por Que as Senhas Ainda Importam
Desde os primórdios dos sistemas de computador de tempo compartilhado na década de 1960, as senhas têm sido o principal guardião entre os usuários e seus dados. Fernando Corbató, o pesquisador do MIT que foi pioneiro no Sistema de Tempo Compartilhado Compatível (CTSS), introduziu senhas em 1961 — não como uma medida de segurança, mas simplesmente para dar a cada usuário um espaço privado para arquivos. Mais de seis décadas depois, as senhas continuam sendo o mecanismo de autenticação mais difundido na internet, protegendo tudo, desde contas de e-mail até sistemas bancários.
No entanto, a pessoa média reutiliza senhas em dezenas de sites, escolhe padrões previsíveis como Verão2024!, e tem pouca intuição sobre o que torna uma senha verdadeiramente impossível de adivinhar. Este artigo faz um mergulho técnico profundo na segurança de senhas: como a entropia é calculada, por que a aleatoriedade é importante, o que dizem as diretrizes mais recentes e como construir hábitos que realmente protejam você.
Entendendo a Entropia: A Matemática da Imprevisibilidade
Entropia na teoria da informação mede a imprevisibilidade. Para senhas, ela responde à pergunta: quantas tentativas um invasor precisaria, em média, para quebrar esta senha?
A fórmula é:
H = L × log₂(N)
Onde:
- H = entropia em bits
- L = comprimento da senha (número de caracteres)
- N = tamanho do conjunto de caracteres (conjunto de caracteres possíveis)
Tamanhos de Conjuntos de Caracteres
| Conjunto de Caracteres | Tamanho (N) | Bits por Caractere |
|---|---|---|
| Apenas letras minúsculas | 26 | 4,7 bits |
| Minúsculas + maiúsculas | 52 | 5,7 bits |
| Alfanumérico | 62 | 5,95 bits |
| ASCII imprimível completo | 94 | 6,55 bits |
| ASCII estendido / Unicode | 128+ | 7+ bits |
Exemplos de Entropia
| Senha | L | N | Entropia (H) |
|---|---|---|---|
senha123 |
8 | 62 | 47,6 bits |
P@ssw0rd |
8 | 94 | 52,4 bits |
k9$mQzLw |
8 | 94 | 52,4 bits |
xK#7pL!qR2@v |
12 | 94 | 78,6 bits |
correct horse battery staple |
28 | 26 | 131,9 bits |
Uma senha com 128+ bits de entropia é considerada computacionalmente inviável de ser quebrada por força bruta com a tecnologia atual. Para contexto, a criptografia AES de 256 bits — considerada inquebrável — corresponde a um espaço de chave de 2²⁵⁶ combinações.
CSPRNG vs Math.random(): Por que a Fonte de Aleatoriedade Importa
Nem todos os números aleatórios são iguais. A diferença entre um gerador de senhas seguro e um inseguro muitas vezes se resume à fonte de aleatoriedade.
Math.random() — Não Adequado para Segurança
O Math.random() integrado do JavaScript é um Gerador de Números Pseudoaleatórios (PRNG). Ele é rápido e estatisticamente uniforme, mas não é criptograficamente seguro. Seu estado interno pode ser inferido a partir de sua saída, o que significa que um invasor que observe valores suficientes poderia prever os valores futuros.
// ❌ Inseguro — NÃO use para geração de senhas
function senhaInsegura(comprimento) {
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
return Array.from({ length: comprimento }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
}
crypto.getRandomValues() — A Ferramenta Certa
A API Web Cryptography fornece crypto.getRandomValues(), que extrai entropia do Gerador de Números Pseudoaleatórios Criptograficamente Seguro (CSPRNG) do sistema operacional. No Linux, isso é o /dev/urandom; no Windows, é o CryptGenRandom. Essas fontes coletam entropia de eventos de hardware (pressionamentos de teclas, E/S de disco, temporização de rede) e são consideradas criptograficamente fortes.
// ✅ Seguro — usa CSPRNG
function gerarSenha(comprimento, conjunto) {
const array = new Uint32Array(comprimento);
crypto.getRandomValues(array);
return Array.from(array, (val) => conjunto[val % conjunto.length]).join('');
}
const conjunto =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=[]{}|;:,.<>?';
console.log(gerarSenha(16, conjunto));
// Exemplo de saída: "aK7!xQz2#Lp9@Wm5"
Nota sobre o viés de módulo: O exemplo acima tem um leve viés de módulo quando o
conjunto.lengthnão divide uniformemente 2³². Para código de produção, use amostragem de rejeição para eliminar totalmente esse viés.
Conjuntos de Caracteres e Complexidade
A maioria dos geradores de senhas oferece opções para:
- Letras minúsculas (a–z): 26 caracteres
- Letras maiúsculas (A–Z): 26 caracteres
- Dígitos (0–9): 10 caracteres
- Símbolos (!@#$%^&*…): ~32 caracteres
A combinação dos quatro resulta em um conjunto de 94 caracteres ASCII imprimíveis. Cada caractere adicional em sua senha multiplica o espaço de busca por 94. Uma senha de 12 caracteres baseada em 94 caracteres possui 94¹² ≈ 4,76 × 10²³ combinações — um número astronômico até mesmo para hardware especializado.
Por que o Comprimento Vence a Complexidade
Muitos sistemas legados exigiam "pelo menos uma letra maiúscula, um dígito, um símbolo", mas permitiam senhas de 8 caracteres. Uma senha de 8 caracteres baseada em 94 caracteres possui apenas 94⁸ ≈ 6 × 10¹⁵ combinações — que pode ser quebrada com um cluster de GPU moderno em poucas horas. Estender para 16 caracteres apenas com letras minúsculas (26¹⁶ ≈ 4,4 × 10²²) na verdade fornece mais entropia do que uma senha complexa de 8 caracteres.
NIST SP 800-63B: Diretrizes Modernas de Senhas
A Publicação Especial 800-63B do NIST do Instituto Nacional de Padrões e Tecnologia dos EUA (Diretrizes de Identidade Digital, 2017, atualizada em 2024) derrubou muitas suposições amplamente difundidas sobre senhas:
O que o NIST Recomenda Agora
- Comprimento mínimo de 8 caracteres para senhas escolhidas pelo usuário; 15 caracteres para senhas geradas por máquina.
- Favorecer o comprimento em vez da complexidade — regras de complexidade obrigatórias (maiúsculas + dígitos + símbolos) não aumentam significativamente a segurança e frustram os usuários.
- Verificar senhas contra listas de violações — rejeitar senhas encontradas em violações de dados conhecidas (por exemplo, via API HaveIBeenPwned).
- Sem rotação periódica forçada, a menos que haja evidência de comprometimento — a rotação forçada leva a padrões previsíveis como
Verão2024→Outono2024. - Sem regras de composição — não exigir tipos de caracteres específicos; em vez disso, permitir todos os caracteres imprimíveis, incluindo espaços.
- Limitar a taxa e bloquear tentativas de autenticação para evitar ataques online.
Essas diretrizes refletem a realidade de que o comportamento humano sob restrições de complexidade é previsível: as pessoas adicionam ! para atender aos requisitos de símbolos, usam letra maiúscula apenas na primeira letra e utilizam anos fáceis de lembrar.
Gerenciadores de Senhas: A Solução Prática
A maior melhoria de segurança que a maioria das pessoas pode fazer é adotar um gerenciador de senhas. Um gerenciador de senhas:
- Gera senhas fortes e exclusivas para cada conta
- Armazena-as em um cofre criptografado (geralmente AES-256)
- Preenche automaticamente as credenciais em navegadores e aplicativos
- Alerta sobre senhas reutilizadas ou vazadas
Gerenciadores de Senhas Populares
| Ferramenta | Tipo | Recurso Notável |
|---|---|---|
| Bitwarden | Código aberto, nuvem/auto-hospedado | Versão gratuita robusta, auditado |
| 1Password | Comercial, nuvem | Modo de viagem, planos familiares |
| KeePass | Código aberto, local | Totalmente offline, ecossistema de plugins |
| KeePassXC | Código aberto, local | Fork multiplataforma do KeePass |
| Dashlane | Comercial, nuvem | Monitoramento da dark web |
A senha mestra para seu gerenciador de senhas deve ser uma frase secreta (passphrase) longa e memorável — a única senha que você memoriza.
Frases Secretas e o Método Diceware
Para senhas que você precisa lembrar (como a senha mestra do seu gerenciador), frases secretas (passphrases) são muito superiores a sequências curtas e complexas.
Como o Diceware Funciona
O método Diceware, criado por Arnold Reinhold em 1995, usa dados físicos para gerar seleções de palavras verdadeiramente aleatórias:
- Obtenha a Lista de Palavras Longa da EFF (7.776 palavras, indexadas de 11111 a 66666 na base 6)
- Jogue 5 dados para obter um número de 5 dígitos (ex: 2-4-1-3-6 → 24136)
- Procure a palavra correspondente (ex: "clump")
- Repita 6 a 8 vezes para construir uma frase secreta
Uma frase secreta Diceware de 6 palavras extraídas de 7.776 palavras possui:
H = 6 × log₂(7776) = 6 × 12,93 ≈ 77,6 bits
"correct horse battery staple" (popularizada pelo XKCD #936) contém 4 palavras de um vocabulário comum de ~2.000 palavras, resultando em ~44 bits de entropia — ilustrativo, mas muito curto. Seis ou mais palavras da lista completa do Diceware é a recomendação prática.
Ataques de Senha Comuns
Entender os ataques ajuda você a calibrar as defesas.
Ataques de Dicionário
Invasores usam listas de palavras — variando de milhões a bilhões de entradas — combinadas com mutações baseadas em regras (colocar a primeira letra em maiúscula, anexar números, substituir @ por a). Ferramentas como Hashcat podem aplicar milhares de regras de mutação por segundo. Qualquer senha derivável de uma palavra de dicionário com substituições simples é vulnerável.
Ataques de Força Bruta
A força bruta pura tenta todas as combinações. Com uma plataforma de GPU dedicada (8× RTX 4090), as velocidades de quebra para algoritmos de hash comuns são:
| Algoritmo de Hash | Velocidade (H/s) | Tempo para quebrar 8 carac. (conjunto de 94) |
|---|---|---|
| MD5 | ~200 GH/s | ~8 horas |
| SHA-1 | ~70 GH/s | ~24 horas |
| bcrypt (custo 10) | ~184 kH/s | ~1.100 anos |
| Argon2id | ~1 kH/s | ~200.000 anos |
Esta tabela ilustra por que o hashing de senha adequado no lado do servidor importa enormemente — mas também por que uma senha aleatória de 16 caracteres resiste até mesmo ao hashing MD5.
Tabelas Arco-Íris (Rainbow Tables)
Tabelas pré-computadas de hash para senha que trocam armazenamento por velocidade. Derrotadas inteiramente pelo salting — adicionar um valor aleatório exclusivo a cada senha antes do hashing. Algoritmos modernos como bcrypt e Argon2 incluem salting por design.
Preenchimento de Credenciais (Credential Stuffing)
Usar pares de nome de usuário/senha vazados de uma violação para atacar outros serviços. A defesa é usar senhas exclusivas por site — que é onde os gerenciadores de senhas brilham.
Por Que a Geração de Senhas no Navegador é Mais Segura
Nossa ferramenta gera senhas inteiramente no seu navegador usando JavaScript. Nenhum dado sai do seu dispositivo. Veja por que isso importa:
- Sem transmissão para o servidor — a senha nunca toca um pacote de rede.
- Sem logs de servidor — não há nada para intimar, vazar ou violar.
- Sem dependências de terceiros no momento da geração — sem chamadas de API, sem scripts externos durante a geração.
- Reproduzível — você pode inspecionar o código-fonte para verificar a lógica.
Compare isso com geradores do lado do servidor: mesmo com HTTPS, a senha gerada existe na memória do servidor, pode aparecer nos logs de acesso e depende inteiramente da confiabilidade do operador.
A API Web relevante é direta:
// O CSPRNG do navegador — disponível em todos os navegadores modernos
const buffer = new Uint8Array(32);
self.crypto.getRandomValues(buffer);
// o buffer agora contém 32 bytes criptograficamente aleatórios
Armazenamento de Senhas: bcrypt, scrypt e Argon2
Quando os serviços armazenam senhas, eles nunca devem armazenar texto simples ou formas criptografadas reversíveis. A abordagem correta é uma função de hashing de senha (PHF) — uma função lenta e unidirecional projetada especificamente para esse propósito.
bcrypt
Projetado em 1999 por Niels Provos e David Mazières, o bcrypt incorpora um fator de custo que pode ser aumentado à medida que o hardware fica mais rápido. Um custo de 12 significa 2¹² = 4.096 iterações da configuração da chave Blowfish. É o padrão hoje e amplamente suportado.
scrypt
Projetado por Colin Percival em 2009. Memory-hard — requer grandes quantidades de RAM além do tempo de CPU, tornando os ataques de GPU/ASIC caros. Parâmetros: N (custo de CPU/memória), r (tamanho do bloco), p (paralelização).
Argon2
Vencedor da Password Hashing Competition (PHC) em 2015. Três variantes:
- Argon2d: resistente a GPU, vulnerável a ataques de canal lateral
- Argon2i: resistente a canal lateral, menos resistente a GPU
- Argon2id: híbrido — o padrão recomendado
Argon2id com m=65536 (64 MB de memória), t=3 (3 iterações), p=4 (4 threads) é o padrão ouro atual para novas aplicações.
Autenticação de Dois Fatores: O Complemento Essencial
Mesmo uma senha perfeita pode ser roubada via phishing, keyloggers ou violações de dados. A autenticação de dois fatores (2FA) garante que uma senha roubada sozinha não seja suficiente.
Métodos 2FA (Do mais fraco ao mais forte)
| Método | Mecanismo | Resistência a Ataques |
|---|---|---|
| SMS OTP | Código enviado por texto | Phishable, vulnerável a SIM-swapping |
| TOTP (Google Authenticator) | Código de 6 dígitos baseado no tempo | Phishable em tempo real |
| Notificação push | Aprovar/negar no telefone | Phishable (fadiga de MFA) |
| Chave de hardware (FIDO2/WebAuthn) | YubiKey, Passkey | Resistente a phishing |
| Passkeys | Chave criptográfica vinculada ao dispositivo | Mais forte; substitui senhas |
Chaves de hardware FIDO2/WebAuthn e passkeys são resistentes a phishing por design porque a resposta ao desafio criptográfico está vinculada ao domínio exato. Um site falso não pode reproduzir a credencial.
Resumo das Melhores Práticas
- Use um gerenciador de senhas — gere e armazene senhas exclusivas para cada conta.
- Mínimo de 16 caracteres para contas confidenciais; 12 no mínimo em qualquer outro lugar.
- Habilite 2FA — de preferência FIDO2/WebAuthn ou TOTP; evite SMS onde possível.
- Nunca reutilize senhas — uma violação em um site não deve comprometer outros.
- Verifique o HaveIBeenPwned — verifique se seus endereços de e-mail e senhas apareceram em violações conhecidas.
- Use uma frase secreta para sua senha mestra — 6+ palavras Diceware, memorável, extremamente forte.
- Desconfie do "teatro da complexidade" —
P@ssw0rd123é muito mais fraco quexK8mLq2vZnRj. - Priorize o comprimento — 20 letras minúsculas aleatórias (94 bits) vencem 12 caracteres complexos (78 bits).
- Atualize senhas violadas imediatamente — mude apenas quando houver comprometimento, não em cronogramas arbitrários.
- Use ferramentas de verificação de violação — serviços como Firefox Monitor ou 1Password Watchtower monitoram suas contas continuamente.
Perguntas Frequentes
P: Qual deve ser o comprimento da minha senha? Para a maioria das contas, 16 caracteres aleatórios de um conjunto completo de 94 caracteres fornecem cerca de 105 bits de entropia — o que é mais do que suficiente. Para contas de alto valor (bancos, e-mail, gerenciador de senhas), use mais de 20 caracteres ou uma frase secreta de 6 palavras.
P: É seguro usar um gerador de senhas online? Apenas se toda a geração ocorrer no lado do cliente (no seu navegador) sem comunicação com o servidor. Nossa ferramenta atende a esse requisito. Verifique conferindo a aba de rede do navegador — nenhuma solicitação deve ser disparada quando você gera uma senha.
P: Devo incluir símbolos? Símbolos aumentam a entropia por caractere (6,55 bits contra 5,17 bits para apenas minúsculas), então sim — se o site permitir. No entanto, uma senha mais longa sem símbolos pode igualar a entropia de uma mais curta com símbolos.
P: Os computadores quânticos podem quebrar minha senha? O algoritmo de Grover oferece aos computadores quânticos uma aceleração quadrática para ataques de força bruta, reduzindo efetivamente os bits de segurança pela metade. Uma chave de 256 bits torna-se segura em 128 bits. Para senhas, isso significa que senhas de 256 bits de entropia seriam necessárias para resistência quântica a longo prazo — alcançável com uma senha de 40 caracteres a partir de 94 caracteres (262 bits). Para a maioria das ameaças atuais, 128 bits de entropia (20 caracteres aleatórios) é mais do que suficiente.
P: O que há de errado com senhas memoráveis como EuAmoPizza2024?
Elas são vulneráveis a ataques de dicionário. O mecanismo de regras do Hashcat gera trivialmente milhões de variações de frases comuns com leetspeak, capitalização e números anexados. Mesmo senhas aparentemente pessoais seguem padrões que os invasores modelam estatisticamente.
P: Como esta ferramenta gera aleatoriedade?
Usamos crypto.getRandomValues() — a API Web Cryptography apoiada pelo CSPRNG do seu sistema operacional. Esta é a mesma fonte de aleatoriedade usada pelo TLS/SSL, geração de chaves SSH e outras operações criptográficas no seu navegador.