O que é Base32 RFC 4648
Base32 representa bytes com as letras A a Z e os dígitos 2 a 7. Cada símbolo carrega cinco bits, por isso o alfabeto tem trinta e dois carateres. O resultado é maior que Base64, mas evita pontuação e costuma funcionar bem em identificadores sem distinção de maiúsculas.
Esta página converte texto Unicode em bytes UTF-8 antes da codificação. Isto preserva acentos, CJK e emoji. Na direção inversa, os símbolos voltam a bytes e esses bytes precisam de formar UTF-8 válido para serem apresentados como texto.
O controlo de preenchimento altera apenas os sinais = finais. A ferramenta aceita formas preenchidas e não preenchidas, mas verifica o comprimento, a quantidade de preenchimento e os bits finais para impedir valores ambíguos.
Como usar o conversor Base32
- Escolha Codificar para texto normal ou Descodificar para uma cadeia Base32.
- Defina se o sistema de destino exige preenchimento até blocos de oito carateres.
- Cole a entrada e corrija qualquer erro de alfabeto, comprimento, preenchimento ou UTF-8.
- Compare o resultado com um vetor oficial ao testar outra biblioteca ou API.
- Inverta a direção para confirmar a ida e volta, lembrando que cada protocolo pode adotar uma política de preenchimento diferente.
Exemplos Base32 e vetores oficiais
Os exemplos combinam vetores da RFC 4648, Unicode e casos com ou sem preenchimento.
| Entrada | Saída | Direção da conversão | Nota |
|---|---|---|---|
f |
MY====== |
Codificar | Incluir preenchimento: Com preenchimento — Vetor RFC: um byte. Um byte gera dois símbolos de dados e seis sinais de preenchimento. |
foobar |
MZXW6YTBOI====== |
Codificar | Incluir preenchimento: Com preenchimento — Vetor RFC: foobar. Vetor de texto completo publicado na secção de testes da RFC 4648. |
Hello |
JBSWY3DP |
Codificar | Incluir preenchimento: Sem preenchimento — Texto sem preenchimento. Os símbolos de dados permanecem; apenas os sinais = finais são removidos. |
jbswy3dp |
Hello |
Descodificar | Descodificação em minúsculas. A entrada minúscula é aceite, embora a saída canónica seja maiúscula. |
你好 |
4S62BZNFXU====== |
Codificar | Incluir preenchimento: Com preenchimento — Unicode em UTF-8. Os carateres chineses são transformados primeiro em seis bytes UTF-8. |
∅ |
∅ |
Codificar | Incluir preenchimento: Com preenchimento — Valor vazio. Uma sequência vazia possui representação Base32 vazia. |
Entrada aceite e forma canónica
A codificação aceita texto Unicode bem formado. A descodificação permite A-Z, 2-7, letras minúsculas e preenchimento apenas no final. Os espaços não são removidos automaticamente.
Sem preenchimento, o comprimento módulo oito só pode ser 0, 2, 4, 5 ou 7. Com preenchimento, o número de sinais = deve corresponder exatamente ao último bloco.
- A saída canónica usa letras maiúsculas.
- O preenchimento só pode aparecer no final.
- 0, 1, 8 e 9 não pertencem ao alfabeto.
- Bits finais diferentes de zero são rejeitados.
- Bytes válidos podem não representar texto UTF-8.
Como o algoritmo Base32 funciona
O codificador acumula bits dos bytes UTF-8 e extrai grupos de cinco para indexar o alfabeto. O grupo final é alinhado e completado apenas para selecionar o último símbolo.
O descodificador reúne grupos de cinco até emitir bytes de oito bits. Depois executa uma descodificação UTF-8 estrita.
As verificações de alfabeto, resíduos de comprimento, preenchimento e bits não usados tornam o comportamento previsível para interoperabilidade.
Quando Base32 é útil
Base32 é útil quando os bytes precisam de circular como texto com um alfabeto pequeno. Não encripta nem autentica os dados.
| Uso | Descrição |
|---|---|
| Segredos TOTP | Muitos autenticadores exibem segredos partilhados como Base32 sem preenchimento. |
| Identificadores sem distinção entre maiúsculas e minúsculas | O alfabeto restrito tolera melhor sistemas que alteram maiúsculas e minúsculas. |
| Protocolos relacionados a DNS | Alguns protocolos usam variantes; confirme o alfabeto exigido. |
| Testes de interoperabilidade | Vetores oficiais revelam falhas em limites e preenchimento. |
| Valores binários visíveis | Evita 0 e 1, embora não forneça correção de erros. |
Erros e limites de Base32
Os erros mais comuns são misturar alfabetos, copiar uma cadeia incompleta ou aplicar o preenchimento de outro formato. Uma cadeia visualmente plausível ainda pode ter comprimento impossível.
Base32 representa bytes. Hashes, chaves e ficheiros podem descodificar como bytes e falhar nesta interface textual por não formarem UTF-8.
- Não substitua 0 por O nem 1 por I.
- Um único símbolo de dados é impossível.
- Preenchimento no meio é inválido.
- O último símbolo pode carregar bits não canónicos.
- Base32 não oferece confidencialidade.
Base32 comparado a outras codificações
Base32 troca tamanho por um alfabeto simples. Base64 é mais compacto; Base58 foi pensado para transcrição humana por conversão de base inteira.
Crockford Base32, base32hex e z-base-32 usam alfabetos ou regras diferentes. Esta página implementa apenas a forma padrão da RFC 4648.
| Formato | Descrição |
|---|---|
| Base64 | Produz texto menor, mas usa + e / na forma comum. |
| Base58 | Remove símbolos visualmente ambíguos e preserva zeros iniciais sem preenchimento. |
| Hexadecimal | É direto para depuração, porém usa dois carateres por byte. |