Gerar palavras-passe no terminal: o que funciona e o que falha sem avisar

Publicado a por David Carrero

Em maio saiu no Medium um tutorial com um título difícil de ignorar: Generate Unbreakable Passwords in Your Terminal Using Pure Bash. A ideia de fundo é boa e partilhamo-la: o terminal já traz um excelente gerador de palavras-passe, não é preciso instalar nada e a palavra-passe não sai da tua máquina. É o mesmo que este site defende com o gerador do navegador, só que sem navegador.

Por isso copiámos os comandos e corremo-los num Mac, a 10 de novembro de 2026, com o macOS 27.2 e as definições regionais em espanhol. E num Linux, para comparar. O que funciona, funciona muito bem. O que falha, em vários casos, falha sem dizer nada, que é o pior que pode acontecer a um gerador de palavras-passe.

De onde vem o acaso

O tutorial abre com o que realmente importa: openssl rand -base64 32 dá-te 32 bytes aleatórios codificados em base64, e /dev/urandom é a fonte de onde bebem quase todos os outros comandos.

Uma ressalva, porque o tutorial conta isto de forma um pouco mais romântica do que é. Nem openssl rand nem /dev/urandom te entregam «aleatoriedade física pura»: ambos são um gerador criptográfico —um CSPRNG— que o sistema operativo semeia com ruído real do hardware e que, a partir daí, produz bytes que ninguém consegue prever. O OpenSSL di-lo na sua documentação: é um gerador determinístico do modelo NIST SP 800-90A que se semeia e se ressemeia sozinho a partir do sistema. O Linux usa um baseado em ChaCha20; o macOS, segundo o guia de segurança da Apple, um derivado do Fortuna.

Não é um defeito, é a razão pela qual funciona: um CSPRNG bem semeado é exatamente o que queres. É a mesma classe de fonte que crypto.getRandomValues(), a que o gerador deste site usa.

E há outro acerto de que o tutorial não se gaba e devia: o truque de tr -dc —ficar só com os bytes que caem dentro do alfabeto e deitar fora o resto— não introduz enviesamento. É o correto. A forma ingénua, pegar no byte e calcular o resto da divisão pelo tamanho do alfabeto, favorece uns caracteres em relação a outros; descartar não.

Num Mac, o comando devolve uma letra

Este é o comando do tutorial para uma palavra-passe de letras e números:

cat /dev/urandom | tr -dc 'a-zA-Z0-9' | head -c 32

No Mac, com as definições regionais em espanhol, o que sai é isto:

tr: Illegal byte sequence

E por baixo, um E. Uma única letra. O código de saída é 0: para o terminal, a operação correu bem.

A causa é que o tr do macOS lê a entrada como texto na codificação das tuas definições regionais, UTF-8, e os bytes aleatórios quase nunca formam UTF-8 válido. Assim que encontra o primeiro que não encaixa, para. O que tinha filtrado até esse momento —às vezes nada, às vezes um par de caracteres— é o que chega ao head, e o head não tem maneira de saber que esperava 32.

No Linux isto não acontece: o tr do GNU trabalha por bytes e não olha para as definições regionais. Experimentámos num contentor Debian e saíram os 32 caracteres. É por isso que um tutorial escrito e testado em Linux pode estar perfeitamente certo para quem o escreveu e partir-se no Mac de quem o lê.

A solução é uma variável à frente: LC_ALL=C tr -dc …, que diz ao tr para tratar a entrada como bytes. Mas o importante não é a solução, é a forma da falha. A função genpass que o tutorial propõe, posta no .bashrc de um Mac, imprime esse E como se fosse uma palavra-passe. Se o colares de olhos fechados num campo sem comprimento mínimo, passa a ser essa a tua palavra-passe.

O hífen que não era um hífen

Para a versão «com símbolos», o tutorial usa este alfabeto:

tr -dc 'a-zA-Z0-9!@#$%^&*()_+-=[]{}'

A intenção é clara: letras, algarismos e dezoito símbolos. Mas para o tr, um hífen entre dois caracteres é um intervalo, tal como em a-z. Portanto +-= não significa «mais, hífen, igual»: significa tudo o que há entre + e = na tabela ASCII, o que inclui a vírgula, o ponto, a barra, os dez algarismos, os dois pontos, o ponto e vírgula e o sinal de menor.

Medimo-lo gerando dois milhões de bytes e ficando com os caracteres distintos que saíram: 86, não os 80 pretendidos. Igual no macOS e no Linux. Não é um problema de segurança —seis caracteres a mais dão um pouco mais de entropia, não menos—, o problema é não saberes o que estás a gerar. Se o sistema onde vai a palavra-passe rejeitar o ; ou o <, o comando falha de vez em quando e não há maneira de adivinhar porquê. A regra é pôr o hífen no fim do conjunto, onde o tr o lê como hífen.

E contamos isto com humildade, porque ao escrever a versão corrigida mais abaixo caímos numa armadilha da mesma família: pusemos o alfabeto como valor por omissão de um parâmetro, ${2:-…{}-}, e a primeira chaveta de fecho do alfabeto fechava o parâmetro. O resultado gerava uma | que ninguém tinha pedido e tinha perdido o hífen. Só demos por isso porque contámos os caracteres que saíam.

64 caracteres que às vezes são 58

O modo por omissão da função faz isto:

openssl rand -base64 48 | tr -dc 'a-zA-Z0-9' | head -c "$LENGTH"

48 bytes em base64 são 64 caracteres. Mas o base64 inclui + e /, e o filtro deita-os fora, por isso o que fica é um pouco menos de 64. Para os 32 do comprimento por omissão, chega e sobra. Para genpass 64, não: corremo-lo 200 vezes e só 28 saíram com 64 caracteres; o resto, entre 58 e 63. Sem aviso.

O modo hexadecimal tem a sua própria versão do mesmo problema: divide o comprimento por dois para calcular os bytes, por isso genpass 15 hex devolve 14.

O avaliador que aplaude P@ssw0rd

O tutorial fecha com um script que pontua palavras-passe: pontos pelo comprimento, um por ter minúsculas, outro por maiúsculas, outro por algarismos e dois por símbolos. Corremo-lo com algumas:

  • P@ssw0rd — STRONG
  • Verao2026! — STRONG
  • correct-horse-battery-staple — STRONG
  • 35 vezes a letra a — MODERATE

P@ssw0rd sai com a mesma nota que quatro palavras ao acaso. É das primeiras que qualquer dicionário de ataque experimenta. O script não tem como sabê-lo, porque não olha para o que a palavra-passe é, só para os tipos de caracteres de que é feita. É exatamente a regra de «uma maiúscula, um número e um símbolo» que o NIST deixou de recomendar em 2017, e de que já falámos em o jogo das palavras-passe.

Há um segundo problema, mais prático: o script recebe a palavra-passe como argumento, ./scorepass.sh "P@ssw0rd". Isso deixa-a escrita no histórico da tua shell —em ~/.zsh_history ou ~/.bash_history— e, enquanto corre, visível para qualquer outro utilizador da máquina que liste os processos. Para testar uma palavra-passe a sério, o verificador deste site procura padrões, dicionários e substituições como @ por a, e fá-lo no teu navegador sem enviar nada.

Quanto é suficiente

O tutorial vende os 256 bits de openssl rand -base64 32 como «a mesma força que protege as transações bancárias». O número está certo e a comparação está a mais: 256 bits é muitíssimo mais do que uma palavra-passe precisa. Com o modelo de ataque do resto do site —10¹² tentativas por segundo, offline e com um hash rápido—, 128 bits já chegam a 10¹⁹ anos. Não há mal nenhum em usar 256, mas não convém confundir «mais» com «necessário». Explicamo-lo com calma em quanto tempo demora a quebrar uma palavra-passe.

Dois pormenores dos formatos, que não são de segurança mas de utilização:

  • O base64 não é seguro para URL, embora o tutorial o diga: inclui +, / e o = do fim. Esse = é enchimento, não acaso; os 256 bits viajam nos 43 caracteres da frente. Existe uma variante, o base64url, que troca + e / por - e _, mas o openssl rand -base64 não a usa.
  • O hexadecimal dá 4 bits por carácter, metade de um alfabeto de letras, algarismos e símbolos. openssl rand -hex 32 produz 64 caracteres e 256 bits: perfeito para uma chave de API. Mas genpass 16 hex dá 16 caracteres e 64 bits, que com esse mesmo modelo de ataque caem, em média, em cerca de 107 dias. Parece comprida; não é assim tanto.

As palavras, e um exemplo que não saiu de nenhum comando

O modo words tira palavras de /usr/share/dict/words com o shuf. Num Mac, o shuf não existe: é do GNU e o macOS não o traz, por isso esse modo simplesmente não funciona. A lista está lá, e tem 235.976 palavras, o que daria cerca de 71 bits com quatro. Muito. O problema é que boa parte são palavras que nunca viste, e a graça de uma frase de palavras é conseguires lembrar-te dela.

O exemplo de saída que o tutorial mostra, correct-horse-battery-staple, não foi gerado por nenhum comando: é a frase da tira 936 do XKCD, de 2011. Essa tira tem razão no que diz —quatro palavras escolhidas ao acaso ganham a uma palavra com substituições—, mas o tutorial resume-a como «o comprimento ganha sempre à complexidade», e não é isso que ela diz. O que ganha é o número de opções entre as quais se escolheu ao acaso. Trinta e cinco «a» têm comprimento de sobra e nenhuma entropia. Se queres frases de palavras bem feitas, o Diceware usa uma lista de 7.776 palavras pensadas para se memorizarem, a 12,9 bits cada uma.

Uma versão que falha em voz alta

É isto que propomos. Antes de a publicar, testámo-la em bash e zsh no macOS e em bash no Linux:

genpass() {
  local n="${1:-20}" set='A-Za-z0-9!@#%^&*()_+=-' pw
  [ -n "$2" ] && set="$2"
  pw=$(LC_ALL=C tr -dc "$set" < /dev/urandom | head -c "$n")
  [ "${#pw}" -eq "$n" ] || { echo "genpass: falhou" >&2; return 1; }
  printf '%s\n' "$pw"
}

Três decisões, cada uma por causa de uma das falhas de cima:

  • LC_ALL=C à frente do tr, para que num Mac leia bytes e não pare.
  • O hífen no fim do alfabeto, para que seja um hífen. Verificámo-lo contando: saem exatamente os 75 caracteres que lá estão escritos, nem um a mais.
  • A verificação do comprimento. Se, por alguma razão, sair uma palavra-passe mais curta do que a pedida, a função não a imprime, avisa pela saída de erros e devolve um código diferente de 0. Que um gerador falhe, tudo bem. Que falhe e entregue alguma coisa é o que não pode acontecer.

genpass dá 20 caracteres desse alfabeto, cerca de 124 bits. genpass 32 dá 32. genpass 6 0-9 dá um PIN. O alfabeto deixa de fora de propósito o $, o acento grave e as aspas: são os caracteres que uma shell ou um ficheiro de configuração interpretam, e uma palavra-passe que se parte ao colá-la num .env não é mais segura, é mais incómoda.

O que o tutorial acerta no fim

A última secção do tutorial é a melhor: gerar é fácil, o difícil é não repetir. Uma palavra-passe de 256 bits usada em dois sites fica comprometida nos dois no dia em que um deles sofre uma fuga de dados. A proposta —gerar no terminal e guardar num gestor como o Bitwarden ou o KeePass— é exatamente a única regra que sobreviveu.

Um último aviso sobre a outra sugestão, copiar para a área de transferência com pbcopy ou xclip. É melhor do que imprimi-la no ecrã, mas a área de transferência não é um sítio privado: os gestores de área de transferência guardam histórico, e num Mac com o Handoff ativo o que copias pode aparecer também no teu iPhone. Copia, cola e copia outra coisa por cima.


Fontes: o tutorial «Generate Unbreakable Passwords in Your Terminal Using Pure Bash», publicado no Medium a 12 de maio de 2026 · todos os comandos foram executados a 10 de novembro de 2026 no macOS 27.2 (bash 3.2, zsh, o tr do sistema, OpenSSL 4.1) e num contentor Debian estável com GNU coreutils 9.7 · documentação do OpenSSL, RAND(7): gerador determinístico segundo NIST SP 800-90A Rev. 1, semeado a partir do sistema operativo · página de manual random(4) do Linux · Apple, Apple Platform Security, geração de números aleatórios · XKCD 936, «Password Strength» (2011) · NIST SP 800-63B (2017) sobre as regras de composição · o modelo de ataque, 10¹² tentativas por segundo offline e com hash rápido, é o mesmo do resto do site.

Foto de Luis Gomes · Pexels

← Voltar ao blog