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— STRONGVerao2026!— STRONGcorrect-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 oopenssl rand -base64não a usa. - O hexadecimal dá 4 bits por carácter, metade de um alfabeto de letras,
algarismos e símbolos.
openssl rand -hex 32produz 64 caracteres e 256 bits: perfeito para uma chave de API. Masgenpass 16 hexdá 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 dotr, 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