Gerador de Senhas

O que é um Gerador de Senhas?

Um gerador de senhas cria sequências aleatórias de caracteres utilizadas como senhas para contas de usuários, API keys, credenciais de banco de dados e segredos de criptografia. Ao contrário de senhas escolhidas por humanos, as senhas geradas exploram todo o espaço de combinações possíveis de caracteres, tornando-as resistentes a ataques de dicionário e adivinhação baseada em padrões. Esta ferramenta gera senhas aleatórias fortes online usando o gerador de números aleatórios criptográfico integrado ao seu navegador.

A força de uma senha depende de dois fatores: comprimento e diversidade de caracteres. Uma senha de 20 caracteres com maiúsculas, minúsculas, dígitos e símbolos possui aproximadamente 131 bits de entropia. Nesse nível, um ataque de força bruta testando um trilhão de tentativas por segundo levaria mais tempo do que a idade do universo para tentar todas as combinações. A matemática é direta: entropia = comprimento x log2(tamanho do conjunto de caracteres).

Padrões como o NIST SP 800-63B recomendam senhas de pelo menos 8 caracteres sem limite superior imposto pelo verificador, e desencorajam regras de composição forçadas — como exigir exatamente um símbolo — favorecendo frases de acesso mais longas. Para credenciais máquina a máquina e contas de serviço, 20 ou mais caracteres aleatórios extraídos de um conjunto completo de caracteres é o padrão aceito na maioria dos frameworks de segurança e regimes de conformidade.

Por que usar um Gerador de Senhas?

Humanos são péssimos geradores de números aleatórios. Reutilizamos senhas, escolhemos palavras do dicionário, substituímos letras com padrões previsíveis (@ por a, 3 por e) e tendemos a usar sequências curtas. Um gerador de senhas elimina o viés humano do processo.

Casos de Uso do Gerador de Senhas

Referência de Entropia de Senhas

A entropia mede o quanto uma senha é imprevisível. É calculada como log2(charset_size ^ length). Maior entropia significa mais combinações possíveis para um atacante percorrer. NIST e OWASP recomendam pelo menos 80 bits de entropia para aplicações de alta segurança.

Os tempos de quebra assumem 1 trilhão de tentativas por segundo (ataque offline com GPUs modernas). Ataques online com limitação de taxa são ordens de magnitude mais lentos.

CSPRNG vs Math.random() para Geração de Senhas

A fonte de aleatoriedade importa tanto quanto o comprimento da senha. Uma senha gerada com um gerador de números aleatórios previsível pode ser reconstruída por um atacante que conhece o algoritmo e o estado da semente. Esta ferramenta usa crypto.getRandomValues(), que é um gerador de números pseudoaleatórios criptograficamente seguro (CSPRNG) integrado a todos os navegadores modernos.

Exemplos de Código

Gere senhas programaticamente em diferentes linguagens. Cada exemplo abaixo usa uma fonte de aleatoriedade criptograficamente segura, não Math.random() ou PRNGs fracos equivalentes.

// Generate a random password in the browser or Node.js 19+
function generatePassword(length = 20) {
  const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*'
  const values = new Uint32Array(length)
  crypto.getRandomValues(values)
  return Array.from(values, v => charset[v % charset.length]).join('')
}

console.log(generatePassword())    // → "kR7!mZp$Xw2&nLq9@Yf3"
console.log(generatePassword(32))  // → "Hd4%tNx!Qw8#mKp2Rv6&Zj0*Ls3Yb7@"

import secrets
import string

def generate_password(length: int = 20) -> str:
    """Generate a cryptographically secure random password."""
    alphabet = string.ascii_letters + string.digits + string.punctuation
    return ''.join(secrets.choice(alphabet) for _ in range(length))

# Single password
print(generate_password())      # → "kR7!mZp$Xw2&nLq9@Yf3"

# Batch of 5 passwords
for _ in range(5):
    print(generate_password(24))

# Ensure at least one char from each category
def generate_strong(length: int = 20) -> str:
    required = [
        secrets.choice(string.ascii_uppercase),
        secrets.choice(string.ascii_lowercase),
        secrets.choice(string.digits),
        secrets.choice(string.punctuation),
    ]
    remaining = length - len(required)
    alphabet = string.ascii_letters + string.digits + string.punctuation
    all_chars = required + [secrets.choice(alphabet) for _ in range(remaining)]
    secrets.SystemRandom().shuffle(all_chars)
    return ''.join(all_chars)

# OpenSSL — generate 32 random bytes, base64-encode
openssl rand -base64 32
# → "x7Kp2mNqR4wZ8vLs1Yb0Hd6tFj3Xc9Ga5eUi+Wo="

# /dev/urandom with tr — alphanumeric + symbols, 20 chars
tr -dc 'A-Za-z0-9!@#$%^&*' < /dev/urandom | head -c 20; echo
# → "kR7!mZp$Xw2&nLq9@Yf3"

# pwgen (install: apt install pwgen / brew install pwgen)
pwgen -sy 20 5
# Generates 5 passwords, 20 chars each, with symbols

package main

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

func generatePassword(length int) (string, error) {
    charset := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
    result := make([]byte, length)
    for i := range result {
        idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
        if err != nil {
            return "", err
        }
        result[i] = charset[idx.Int64()]
    }
    return string(result), nil
}

func main() {
    pwd, _ := generatePassword(20)
    fmt.Println(pwd) // → "kR7!mZp$Xw2&nLq9@Yf3"
}

Perguntas Frequentes