Como codificar texto em Base32
- Digite ou cole o texto em Entrada · Texto. Com Ao vivo marcado, a saída é atualizada a cada tecla.
- Leia o resultado em Saída · Base32 (RFC 4648). Desmarque Preenchimento (=) abaixo da saída para remover os sinais
=do final. - Para outra variante, abra Para e escolha Base32hex, Crockford Base32 ou z-base-32.
- Para decodificar, clique em Base32 (RFC 4648) → Texto no seletor de direção. O decodificador Base32 dedicado já começa nessa direção.
- Use Copiar saída ou Baixar para levar o resultado.
O texto é convertido em bytes como UTF-8 por padrão. Se você precisa do Base32 do mesmo texto em outra codificação, por exemplo Windows-1252 ou UTF-16LE, mude o Charset abaixo da entrada.
Como o Base32 funciona
O Base32 lê a entrada de 5 em 5 bits e escreve um caractere para cada 5 bits. Cinco bytes (40 bits) viram exatamente oito caracteres, então a saída é 60% maior que a entrada. Uma string Base64 dos mesmos dados seria 33% maior; esse é o preço que o Base32 paga por usar só letras maiúsculas e seis dígitos.
Quando o comprimento da entrada não é múltiplo de 5 bytes, o último grupo é completado com = até 8 caracteres. Estes são os vetores de teste da RFC 4648, gerados por esta ferramenta:
| Entrada | Base32 | Sem preenchimento |
|---|---|---|
f | MY====== | MY |
fo | MZXQ==== | MZXQ |
foo | MZXW6=== | MZXW6 |
foob | MZXW6YQ= | MZXW6YQ |
fooba | MZXW6YTB | MZXW6YTB |
foobar | MZXW6YTBOI====== | MZXW6YTBOI |
O preenchimento não carrega dados. Um decodificador consegue calcular o número de bytes pela quantidade de caracteres reais, e é por isso que muitos formatos o descartam.
Variantes do Base32: RFC 4648, base32hex, Crockford, z-base-32
“Base32” é o nome de uma família. Os quatro membros empacotam 5 bits por caractere; eles diferem no alfabeto e no uso de preenchimento. Os mesmos cinco bytes, Hello, em cada um:
| Variante | Alfabeto | Hello | Preenchimento | Onde aparece |
|---|---|---|---|---|
| Base32 da RFC 4648 | A–Z, 2–7 | JBSWY3DP | = | Segredos TOTP/2FA, endereços onion v3 do Tor, IPFS CIDv1 (b…, em minúsculas) |
| Base32hex | 0–9, A–V | 91IMOR3F | = | Registros NSEC3 do DNSSEC; as strings codificadas ficam na mesma ordem que os bytes |
| Crockford Base32 | 0–9, A–Z sem I L O U | 91JPRV3F | nenhum | IDs que pessoas leem em voz alta e digitam |
| z-base-32 | ybndrfg8ejkmcpqxot1uwisza345h769 | jb1sa5dx | nenhum | Chaves e identificadores pensados para pessoas |
Base32hex e Crockford se parecem, mas são alfabetos diferentes: depois do H eles divergem, então 91IMOR3F e 91JPRV3F são os mesmos bytes. Escolher o errado decodifica sem erro e entrega bytes diferentes sem avisar.
O decodificador Crockford daqui é tolerante do jeito que Crockford pretendia: ele lê I e L como 1, O como 0 e ignora hifens, então 91JP-RV3F ainda dá Hello. Ele não acrescenta nem verifica o símbolo de verificação opcional do Crockford.
Base32 para segredos TOTP e 2FA
Os apps autenticadores recebem o segredo de um link otpauth://, geralmente mostrado como QR code:
otpauth://totp/Example:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=Example
O parâmetro secret é Base32 da RFC 4648 sem preenchimento. JBSWY3DPEHPK3PXP tem 16 caracteres, então contém 10 bytes. A RFC 4226 recomenda um segredo de 160 bits (20 bytes), que dá 32 caracteres Base32. Se o seu segredo está guardado em Base64 ou hex, converta-o com o Base64 para Base32. Digitar o texto Base64 nesta página codifica os caracteres dele, o que gera Base32 válido, mas dos bytes errados, e todo código gerado a partir dela será rejeitado.
Um segredo TOTP é uma chave: qualquer um que o tenha consegue gerar os seus códigos. Esta página trabalha com o segredo dentro da aba do seu navegador, e o Content Security Policy dela impede que a página faça requisições de rede, exceto as do contador de visitas da Cloudflare.
Base32 na linha de comando e em Python
O GNU coreutils tem um comando base32 que funciona como o base64:
printf 'Hello' | base32
printf 'JBSWY3DP' | base32 -d
A primeira linha imprime JBSWY3DP, a segunda, Hello. A biblioteca padrão do Python tem as três formas da RFC 4648:
import base64
base64.b32encode(b"Hello") # b'JBSWY3DP'
base64.b32hexencode(b"Hello") # b'91IMOR3F'
base64.b32encode(b"Hi").decode().rstrip("=") # 'JBUQ'
Mais receitas de codificação estão na página de Python. Para decodificar, incluindo os erros de preenchimento e de minúsculas que o Python lança, veja o decodificador Base32.
Perguntas frequentes
Por que a saída Base32 termina com ======?
O Base32 trabalha com blocos de 5 bytes que viram 8 caracteres. Quando o último bloco é menor, a RFC 4648 completa o resto dos 8 caracteres com =, então Hi vira JBUQ====. Desmarque Preenchimento (=) se o destino quiser só JBUQ.
O Base32 diferencia maiúsculas de minúsculas?
O alfabeto da RFC 4648 é em maiúsculas, mas a maioria dos decodificadores aceita minúsculas também, e este aceita. O Python é uma exceção: o base64.b32decode rejeita minúsculas, a menos que você passe casefold=True.
Devo usar Base32 ou Base64?
Use Base64 quando só programas leem os dados: ele é mais curto (33% de acréscimo contra 60%). Use Base32 quando pessoas leem, digitam ou ditam o valor, ou quando ele precisa sobreviver a sistemas que não diferenciam maiúsculas, como nomes DNS ou alguns sistemas de arquivos.
Quais caracteres o Base32 usa?
O Base32 da RFC 4648 usa A–Z e 2–7, mais = para preenchimento. Os dígitos 0, 1, 8 e 9 ficam de fora, então uma string que os contém é base32hex, Crockford ou nem é Base32.