Codificador e decodificador Base32
Codifique texto em Base32 RFC 4648, o alfabeto A–Z e 2–7 dos segredos de autenticação: Hello vira JBSWY3DP. Na decodificação, aceita minúsculas e quebras de linha, mas recusa símbolos estranhos. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Texto
- Hello
- Modo de cálculo
- Encode
- Resultado
- JBSWY3DP
- Comprimento
- 8
- Bytes de entrada
- 5
- Alfabeto
- RFC4648
O Base32 transforma texto UTF-8 arbitrário em uma cadeia compacta formada apenas pelas letras de A a Z e pelos dígitos de dois a sete, opcionalmente com preenchimento de sinais de igual para que cada bloco termine em um limite de oito caracteres. Diferente do Base64, o alfabeto evita o sinal de mais, a barra e outros sinais de pontuação que quebram URLs, argumentos de shell ou sistemas de arquivos insensíveis a maiúsculas, e é por isso que sementes secretas, chaves TOTP e muitos tokens de protocolo ainda são distribuídos como Base32. Esta capacidade implementa de ponta a ponta o alfabeto da seção seis da RFC 4648: o modo de codificação lê sua cadeia simples como bytes UTF-8 e emite um resultado Base32 com preenchimento; o modo de decodificação aceita Base32 em maiúsculas e minúsculas, remove espaços em branco, valida cada caractere e devolve o texto UTF-8 original.
Como o Base32 da RFC 4648 empacota bits em A-Z e 2-7
A seção seis da RFC 4648 define um alfabeto de trinta e dois símbolos: as vinte e seis letras latinas maiúsculas seguidas dos seis dígitos de dois a sete. A codificação parte dos bytes brutos. Para texto, esta capacidade primeiro converte sua cadeia com UTF-8, de modo que caracteres de múltiplos bytes permaneçam portáveis entre idiomas e plataformas.
Esses bytes são então lidos como um fluxo contínuo de bits. Cada cinco bits selecionam um índice do alfabeto, produzindo um caractere Base32. Cinco bytes de entrada fornecem quarenta bits, que se dividem exatamente em oito caracteres Base32; restos menores deixam um quinteto final parcial que recebe zeros à direita e depois é completado com preenchimento de sinais de igual, de modo que o comprimento total seja sempre múltiplo de oito.
A decodificação inverte o mapeamento: cada caractere que não é de preenchimento contribui cinco bits, bytes completos são emitidos assim que oito bits se acumulam, e o preenchimento final é verificado quanto à posição legal. Espaços em branco são ignorados, de modo que tokens de várias linhas colados de e-mails ainda funcionam. Letras minúsculas são convertidas em maiúsculas antes da consulta.
Essa rejeição estrita é intencional: uma substituição silenciosa esconderia erros de transcrição em segredos de autenticadores e formatos de transmissão. O padrão implementado nesta página é o clássico alfabeto Base32 da RFC 4648, não o Base32hex nem o Crockford Base32, que usam tabelas de símbolos diferentes e quebrariam a interoperabilidade com TOTP e muitas APIs legadas.
O que você envia e o que recebe de volta
Envie um campo de cadeia obrigatório chamado text e um campo opcional mode definido como encode ou decode. Quando mode é omitido, encode é o padrão, de modo que uma única carga útil ainda realiza trabalho útil. O modo encode trata text como conteúdo UTF-8 simples e devolve uma cadeia result no alfabeto da RFC 4648 com preenchimento.
O modo decode trata text como Base32, normaliza maiúsculas e espaços em branco, valida o alfabeto e devolve a cadeia UTF-8 recuperada em result. Ambas as direções ecoam mode, o text original, result, um campo length para a cadeia de saída principal, rótulos de alphabet e charset, um indicador padding e uma cadeia curta de referência standard, para que os clientes possam verificar qual perfil foi atingido. Falhas de validação não consomem saldo pré-pago.
Verificações clássicas incluem codificar Hello para JBSWY3DP, codificar a letra f isolada para MY com seis sinais de igual de preenchimento e decodificar um bloco conhecido com preenchimento de volta para foobar.
Onde a codificação Base32 aparece no trabalho real
Os segredos de senhas de uso único baseadas em tempo da RFC 6238 e dos aplicativos autenticadores quase sempre trafegam como Base32, para que os usuários possam digitá-los sem confundir zero com a letra O ou um com a letra I tanto quanto confundiriam com Base64. Cargas de QR de provisionamento e códigos de backup precisam, portanto, de um caminho de codificação confiável ao gerar chaves e de um caminho de decodificação estrito ao importá-las.
O DNS e alguns sistemas de configuração de rede preferem alfabetos semelhantes ao Base32 para rótulos opacos que precisam sobreviver à conversão de maiúsculas e minúsculas. Links profundos de celular e tokens curtos offline costumam escolher Base32 porque o conjunto de símbolos é insensível a maiúsculas após a normalização e evita caracteres reservados de URL. Equipes de suporte colam segredos de várias linhas de tickets e precisam de tolerância a espaços em branco sem aceitar símbolos inválidos que produziriam uma chave errada.
Autores de currículos que ensinam esquemas de codificação querem uma página dedicada ao Base32 em vez de enterrá-lo sob uma landing genérica de Base64, pois a intenção de busca e as regras de alfabeto diferem. Se você precisa de Base64 com alfabeto seguro para URL, codificação percentual para URLs ou conversão de inteiros em múltiplas bases, trate-os como intenções de busca e landings separadas, em vez de sobrecarregar esta página de codificador Base32.
Casos de uso
Intercâmbio de segredos TOTP e de autenticadores
Codifique segredos compartilhados recém-gerados como Base32 RFC 4648 para aplicativos autenticadores, ou decodifique sementes Base32 coladas durante a recuperação e importação de contas.
Tokens seguros quanto a maiúsculas para configurações e links
Produza rótulos Base32 que sobrevivem à conversão de maiúsculas e evitam a pontuação + / ao embutir identificadores opacos em nomes semelhantes a DNS ou links profundos.
Perguntas frequentes
Qual alfabeto Base32 esta ferramenta usa?
A seção seis da RFC 4648: A-Z maiúsculas e dígitos 2-7, com preenchimento '=' até um múltiplo de oito caracteres. Não é Base32hex nem Crockford Base32.
Posso codificar e decodificar?
Sim. Defina mode como encode (padrão) para transformar texto UTF-8 simples em Base32, ou mode como decode para recuperar o texto de uma cadeia Base32.
Base32 em minúsculas é aceito na decodificação?
Sim. As letras são convertidas para maiúsculas antes da consulta ao alfabeto. Espaços em branco são removidos, de modo que colagens de várias linhas ainda funcionam.
Quanto custa?
A ferramenta no navegador é gratuita e roda localmente.
Por que o resultado em Base32 termina com sinais de igual?
Eles são o preenchimento, para que o tamanho total seja sempre múltiplo de oito. Cinco bytes enchem exatamente oito caracteres, como Hello em JBSWY3DP, mas uma única letra f vira MY seguida de seis sinais de igual.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/enc/base32 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Hello"}'const res = await fetch("https://api.kit.forhosting.com/enc/base32", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Hello"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/base32",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Hello"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/base32", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Hello"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Hello"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/base32", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"text": "Hello"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.base32",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Um símbolo ilegal durante a decodificação falha imediatamente com invalid_input, de modo que colagens defeituosas nunca corrompem dados silenciosamente.
Como o Base32 da RFC 4648 empacota bits em A-Z e 2-7
Qualquer caractere fora de A-Z, dos dígitos de dois a sete e do sinal de igual de preenchimento gera um erro invalid_input indicando a posição e o símbolo ofensor. Todo o caminho é determinístico, com aritmética inteira livre de ponto flutuante, sem rede, sem sementes aleatórias e sem carimbos de data e hora, portanto entradas idênticas sempre produzem JSON idêntico.
O que você envia e o que recebe de volta
O encode também informa input_bytes; o decode informa output_bytes. Texto ausente, objetos que não são cadeias, valores de mode não suportados, cadeias mais longas que o máximo documentado, caracteres Base32 ilegais, preenchimento após um caractere que não é de preenchimento, excesso de sinais de preenchimento ou comprimentos que não são múltiplos de oito falham com invalid_input e uma mensagem clara em inglês. O preço das chamadas de API bem-sucedidas é a base publicada de US$ 0,002 por item.
Onde a codificação Base32 aparece no trabalho real
Como esta capacidade é um motor de parse puro, o preço da API é a base publicada de US$ 0,002 por item bem-sucedido, e a validação com falha não consome saldo.
Casos de integração
Vetores de teste golden entre linguagens
Gere fixtures de codificação e decodificação que correspondam ao Base32 do Python, do Go e do OpenSSL, para que a CI multilinguagem compartilhe uma única fonte de verdade.
Perguntas técnicas
O que acontece se a cadeia Base32 tiver um caractere inválido?
A decodificação falha com invalid_input, indicando a posição e o caractere ilegal. Nada é cobrado por falhas de validação.