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

> O terminal é um bom gerador de palavras-passe e não é preciso instalar nada. Mas experimentámos num Mac os comandos de um tutorial muito completo e metade falhava: um devolvia uma única letra sem dar erro. O que se passa, porquê, e uma versão que falha em voz alta.

2026-11-10 · David Carrero · password.es
Original: https://password.es/pt/blog/gerar-palavras-passe-no-terminal/

---

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](/pt/blog/porque-nao-enviamos-a-tua-palavra-passe/), 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](/pt/) 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](/pt/blog/o-jogo-das-palavras-passe-e-as-regras-que-nao-protegem/).

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](/pt/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](/pt/blog/quanto-tempo-demora-mesmo-a-quebrar-a-tua-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](/pt/blog/o-que-sao-os-bits-de-entropia/), 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](/pt/blog/diceware-dados-melhor-palavra-passe/) 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:

```bash
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](/pt/blog/o-teu-gestor-contra-a-tua-memoria/).

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.*
