Ferramenta de Geração e Validação de Senhas

Gere senhas fortes e frases-passe, com suporte a validação em lote, unicidade, força e políticas, além de exemplos de código em múltiplas linguagens e conhecimentos práticos.

Testador de Política de Senha

Senha a ser testada

Comprimento mínimo Exigir letras minúsculas Exigir letras maiúsculas Exigir números Exigir símbolos Proibir sequências consecutivas (como abc, 123) Proibir repetições longas (como aaaa)

Resultados

Comprimento
Letras minúsculas
Letras maiúsculas
Números
Símbolos
Sequências consecutivas
Repetições
Lista negra

Todos os testes são realizados localmente no seu navegador.

Gerador de Frases-Senha

Número de palavras

Separador

Capitalizar primeira letra Adicionar número

As palavras são selecionadas aleatoriamente com segurança (Web Crypto). A lista de demonstração é limitada por restrições de tamanho.

Tabela de Referência Rápida para Hash de Senha

Argon2id

Use Argon2id com parâmetros de memória adequados
Iterações ≥ 2, memória ≥ 64MB (ajuste conforme o ambiente)
Armazene sal independente por usuário; opcionalmente use pepper na camada da aplicação

PBKDF2

Escolha SHA-256 ou SHA-512 com iterações ≥ 210k (ajuste conforme necessário)
Use sal único por hash; suporte a atualização de parâmetros
Migre para parâmetros de custo mais elevado na próxima autenticação do usuário

BCrypt

Custo entre 10 e 14, dependendo da capacidade do servidor
Evite truncamento; faça hash da senha completa
Implemente rate limiting e monitoramento nos endpoints de autenticação

Referência: NIST SP 800-63B, OWASP ASVS. Os parâmetros devem ser compatíveis com a capacidade do hardware e os SLOs.

Avaliação de Força da Senha

A força é aproximada pela entropia: entropy = log2(tamanho do conjunto de caracteres) × comprimento. Um conjunto de caracteres maior e um comprimento mais longo aumentam a resistência a tentativas de adivinhação.

Fraca: < 50 bits —— Apenas adequado para cenários temporários ou de baixo valor
Razoável: 50–80 bits —— Aceitável para cenários de baixo risco
Forte: 80–110 bits —— Objetivo padrão recomendado
Excelente: > 110 bits —— Recomendado para contas de administrador ou críticas

Dica: Modelos de ataque reais podem variar; evite reutilizar senhas e ative autenticação multifator (MFA).

Instruções de Uso

Escolha o comprimento e o conjunto de caracteres (minúsculas/maiúsculas/dígitos/símbolos); ative opcionalmente 'Evitar caracteres semelhantes' e 'Exigir cada tipo'
Para controle mais preciso: exclua caracteres ou grupos específicos, ou selecione grupos de símbolos pré-definidos
Clique em Gerar; para múltiplos resultados, ative a geração em lote e copie todos com um clique
Para validar senhas existentes, use o 'Testador de Políticas'; para frases-passe memorizáveis, use o 'Gerador de Frases-Passe'

Recursos

Fonte aleatória segura (Web Crypto)
Conjuntos de caracteres e grupos de símbolos configuráveis
Filtro de caracteres semelhantes e exclusão personalizada
Geração em lote, garantia de unicidade e estatísticas de duplicatas
Métricas de força e entropia
Testador de políticas e gerador de frases-passe
Exemplos de código em múltiplas linguagens （JS、Python、PHP、Go、Java、C#、Rust）
Copiar com um clique (único/todos)

Exemplos de Geração de Senha

Forte (Strong)

Comprimento 24, incluindo maiúsculas/minúsculas/números/símbolos

Memorável (Memorable)

Comprimento 16, incluindo maiúsculas/minúsculas/números, evitando caracteres semelhantes

Banco de Conhecimento de Senhas

1) Força da senha e entropia

Entropia ≈ log2(tamanho do conjunto de caracteres) × comprimento; o comprimento geralmente tem maior impacto
Meta recomendada: contas comuns ≥ 80 bits; contas com alto privilégio/financeiras ≥ 110 bits
Conjunto de caracteres maior + comprimento maior → maior resistência a tentativas de adivinhação

2) Comprimento vs complexidade

Adicionar símbolos aleatoriamente é menos eficaz do que aumentar o comprimento
Evite padrões previsíveis fixos (como sempre "primeira letra maiúscula + número no final!")
Priorize garantir um comprimento suficiente, depois aumente levemente a diversidade dos caracteres

3) Erros comuns e anti-padrões

Sequências de teclado (qwerty), blocos repetidos, datas de nascimento/anos são fáceis de adivinhar com regras comuns
"Senha raiz + sufixo do site" é uma forma de reutilização de variações, com risco concentrado e fácil de adivinhar
Não reutilize a mesma senha em vários sites

4) Recomendações para gerenciamento de senhas

Use um gerenciador de senhas; senhas únicas por site; ative MFA para contas importantes
Evite transmitir senhas em texto plano por canais públicos; se necessário, use senhas "amigáveis à pronúncia"
Ao descobrir vazamento ou reutilização, mude imediatamente e garanta unicidade

5) Guia para frases-senha (Passphrase)

Combinações de 4–6 palavras geralmente são fortes e fáceis de lembrar
Misture delimitadores, letras maiúsculas iniciais e números para aumentar força e legibilidade
Evite concatenações diretas de frases comuns, letras de músicas ou citações famosas

Guia de Práticas de Segurança de Senhas

Práticas Recomendadas

Use comprimentos suficientes: 16+ para contas gerais, 24+ para contas críticas
Para memorização, prefira frases de senha; senhas aleatórias e de alta intensidade devem ser armazenadas por gerenciadores de senhas
Habilite autenticação multifator (MFA) sempre que possível
Não reutilize senhas entre sites diferentes; cada conta deve ter uma senha única

Entropia e Força

A entropia reflete a imprevisibilidade com base no comprimento e no tamanho do conjunto de caracteres; quanto maior o número de bits de entropia, geralmente mais forte será a senha.

Aumentar o comprimento oferece o maior ganho em segurança
Use conjuntos de caracteres variados sempre que possível
Excluir excessivamente caracteres reduz o conjunto disponível e diminui a força

Políticas e Rotação

Prefira regras baseadas em comprimento e listas negras de senhas comuns/comprometidas em vez de regras complexas de composição
Evite rotações frequentes obrigatórias; altere apenas em caso de vazamento ou risco identificado
Use listas de senhas comprometidas para bloquear senhas comuns ou vazadas

Frases de Senha

Use 4–6 palavras aleatórias conectadas por separadores, por exemplo: lake-CARROT-planet_7
Evite frases comuns como citações ou letras de músicas; a aleatoriedade é mais importante que 'criatividade'
Para contas críticas, recomenda-se usar um gerenciador de senhas para armazenar senhas aleatórias de alta entropia

Dicas de Configuração de Geração

"Require each selected set" garante que pelo menos um caractere de cada tipo seja incluído
"Avoid similar" melhora a legibilidade, mas reduz ligeiramente o tamanho do conjunto de caracteres
Símbolos podem ser limitados ao subconjunto aceito pelo sistema alvo

Armazenamento no Servidor

Nunca armazene senhas em texto simples; use hash forte (Argon2id/PBKDF2/BCrypt) com salt
Configure parâmetros adequadamente (memória/tempo/custo); considere o uso de pepper quando necessário
Limite taxas de tentativas e monitore falhas; durante ataques, adicione CAPTCHA ou verificação de dispositivo

Autenticação Multifator e Recuperação

Prefira TOTP ou chaves de hardware; evite SMS sempre que possível
Proteja os processos de recuperação: use múltiplos fatores ou verificação por e-mail com período de resfriamento
Forneça códigos de recuperação de reserva e incentive os usuários a guardá-los com cuidado

Proteção contra Ataques de Força Bruta

Use atrasos progressivos/bloqueios e pontuações de risco por IP/dispositivo
Configure WAF e limites de taxa para APIs e formulários de login
Monitore tentativas de credential stuffing e incentive o uso de senhas únicas

Armazenamento e Processamento Local

Use gerenciadores de senhas confiáveis para armazenamento e preenchimento automático
Não compartilhe senhas em texto simples por chat ou e-mail; use ferramentas de gerenciamento de segredos em equipes
Se precisar registrar offline, garanta segurança física

Declaração: Esta ferramenta gera senhas localmente no navegador usando Web Crypto; nenhum dado é enviado ao servidor.

Como gerar senhas através de linguagens de programação

JavaScript（Web Crypto）

function randomPassword(length = 16, sets = {lower:true, upper:true, digits:true, symbols:true}) {
  const pools = {
    lower: 'abcdefghijklmnopqrstuvwxyz',
    upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
    digits: '0123456789',
    symbols: '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
  };
  let pool = '';
  for (const k of Object.keys(sets)) if (sets[k]) pool += pools[k];
  if (!pool) throw new Error('No charset');
  const bytes = new Uint32Array(length);
  crypto.getRandomValues(bytes);
  let out = '';
  for (let i = 0; i < length; i++) out += pool[bytes[i] % pool.length];
  return out;
}

Python（secrets）

import secrets

def random_password(length=16, lower=True, upper=True, digits=True, symbols=True):
    pools = {
        'lower': 'abcdefghijklmnopqrstuvwxyz',
        'upper': 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits': '0123456789',
        'symbols': '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    }
    pool = ''.join(v for k, v in pools.items() if locals()[k])
    if not pool:
        raise ValueError('No charset')
    return ''.join(secrets.choice(pool) for _ in range(length))

PHP（random_int）

function random_password($length = 16, $sets = ['lower'=>true,'upper'=>true,'digits'=>true,'symbols'=>true]) {
    $pools = [
        'lower' => 'abcdefghijklmnopqrstuvwxyz',
        'upper' => 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
        'digits' => '0123456789',
        'symbols' => '!@#$%^&*+-=_~`|/?()[]{}<>,.;:\'\"'
    ];
    $pool = '';
    foreach ($sets as $k => $on) if ($on) $pool .= $pools[$k];
    if ($pool === '') throw new Exception('No charset');
    $out = '';
    for ($i = 0; $i < $length; $i++) {
        $out .= $pool[random_int(0, strlen($pool)-1)];
    }
    return $out;
}

Go（crypto/rand）

package main

import (
  "crypto/rand"
  "math/big"
)

func RandomPassword(length int, pool string) (string, error) {
  out := make([]byte, length)
  for i := 0; i < length; i++ {
    nBig, err := rand.Int(rand.Reader, big.NewInt(int64(len(pool))))
    if err != nil { return "", err }
    out[i] = pool[nBig.Int64()]
  }
  return string(out), nil
}

Java（SecureRandom）

import java.security.SecureRandom;

public class Pw {
  static final String POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
  static final SecureRandom SR = new SecureRandom();
  static String randomPassword(int length) {
    StringBuilder sb = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      int idx = SR.nextInt(POOL.length());
      sb.append(POOL.charAt(idx));
    }
    return sb.toString();
  }
}

C#（.NET RandomNumberGenerator）

using System;
using System.Security.Cryptography;

public static class Pw {
  public static string RandomPassword(int length, string pool) {
    using var rng = RandomNumberGenerator.Create();
    var bytes = new byte[length];
    rng.GetBytes(bytes);
    var chars = new char[length];
    for (int i = 0; i < length; i++) {
      chars[i] = pool[bytes[i] % pool.Length];
    }
    return new string(chars);
  }
}

Rust（rand + getrandom）

use rand::rngs::OsRng;
use rand::RngCore;

fn random_password(length: usize, pool: &str) -> String {
    let mut bytes = vec![0u8; length];
    OsRng.fill_bytes(&mut bytes);
    let chars: Vec = pool.chars().collect();
    bytes
        .iter()
        .map(|b| chars[(*b as usize) % chars.len()])
        .collect()
}

fn main() {
    let pool = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*+-=_~`|/?()[]{}<>,.;:'\"";
    let pw = random_password(16, pool);
    println!("{}", pw);
}