# Decodificar > Decodificar do CatSuite: como usar e configurar a autodetecção de JWT, Base64, URL, Hex, HTML Entities e Binary, além do inspetor JWT/JWE e hashes MD5 e SHA. - Idioma: pt-BR - URL canônica: https://netcattest.com/catsuite/docs/modulos/decodificar - Seção: Módulos - Atualizado: 2026-10-06 - Outro idioma (en): https://netcattest.com/catsuite/en/docs/modules/decoder O **Decodificar** é a bancada de transformação de dados do CatSuite: você cola ou envia um valor do tráfego e o módulo **reconhece o formato**, mostra o conteúdo legível e ainda **gera e identifica hashes**. Ele reúne, em uma só tela, a **autodetecção** de JWT, Base64, URL, Hex, HTML Entities e Binary, o suporte a **Base64URL** e **Unicode**, inspetores dedicados de **JWT**, **assinaturas JWT** e **JWE**, e a geração de **MD5, SHA-1, SHA-256 e SHA-512**. Esta página explica cada conceito, cada opção e como usar e configurar o Decodificar passo a passo, do jeito mais simples para quem está começando. > [!NOTA] > Todo o processamento do Decodificar acontece **localmente**, no próprio aparelho. Nada é enviado para servidores externos. Tokens, segredos e textos colados ficam só no app. ## O que é o Decodificar e para que serve Durante um teste, o tráfego vem cheio de valores "embaralhados": um parâmetro em percent-encoding na URL, um cookie em Base64, um token JWT no header `Authorization`, um corpo com entidades HTML, um dump em hexadecimal. O Decodificar é a ferramenta que **traduz** esses valores de volta para texto legível, e também faz o **caminho inverso** (codificar) quando você precisa montar um valor para reenviar. Casos de uso típicos: - Ler o conteúdo de um **token JWT** (header e payload) sem depender de sites externos. - Decodificar um parâmetro ou cookie em **Base64** ou **Base64URL** para ver o que ele carrega. - Transformar **%20**, `<`, bytes em **Hex** ou blocos **binários** de volta em texto. - **Gerar** o hash de um valor (MD5, SHA-1, SHA-256, SHA-512) para comparar com outro. - **Identificar** rapidamente que tipo de hash é uma string capturada, pelo tamanho. - Inspecionar o envelope de um **JWE** e descobrir quais algoritmos de criptografia ele usa. O Decodificar é um **auxiliar de análise**: ele não envia requisições nem altera o alvo. É a dupla natural do [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador), do [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir) e do [Navegador](https://netcattest.com/catsuite/docs/modulos/navegador), que mandam trechos de tráfego para ele. ## Conceitos essenciais do Decodificar Antes de mexer nas opções, vale entender os termos que aparecem na tela. Cada conceito abaixo corresponde a um formato, um painel ou um botão do módulo. ### Codificar e decodificar **Codificar** é transformar um texto legível no formato de transporte (por exemplo, texto comum para Base64). **Decodificar** é o contrário: partir do formato de transporte e recuperar o texto legível. No painel **FORMATOS**, um alternador escolhe entre os dois modos para o mesmo formato selecionado. ### URL (percent-encoding) A codificação de **URL** troca caracteres especiais por `%XX`. Um espaço vira `%20`, uma chave `{` vira `%7B`, e assim por diante. É o formato dos parâmetros de query e de formulários `application/x-www-form-urlencoded`. Ao decodificar, o Decodificar transforma `%20` de volta em espaço e reconstrói o texto original. ### Base64 O **Base64** representa bytes usando 64 caracteres imprimíveis (`A-Z`, `a-z`, `0-9`, `+`, `/`) com `=` de preenchimento. É muito comum em APIs, cookies, blobs e cabeçalhos. O Decodificar interpreta o texto como bytes UTF-8 ao codificar e reconstrói o texto ao decodificar. ### Base64URL O **Base64URL** é a variante **segura para URL**: troca `+` e `/` por `-` e `_` e costuma **dispensar o `=`** de preenchimento. É o formato dos três segmentos de um **JWT** e de muitos links e tokens. Ao codificar em Base64URL, o Decodificar remove o preenchimento `=`; ao decodificar, ele recompõe o preenchimento necessário automaticamente. > [!DICA] > Se um valor tem `-` e `_` no lugar de `+` e `/`, ou não termina em `=`, provavelmente é **Base64URL**, não Base64 padrão. ### Hexadecimal O **Hexadecimal** (Hex) mostra cada byte como dois dígitos de `0` a `f`. O Decodificar exibe os bytes separados por espaço, no padrão `48 65 78`. Ao decodificar, ele ignora separadores e caracteres fora de `0-9a-f` e remonta os bytes dois a dois. ### HTML Entities As **entidades HTML** escapam caracteres com significado na marcação: `<` vira `<`, `>` vira `>`, `&` vira `&`, `"` vira `"` e `'` vira `'`. O Decodificar converte nos dois sentidos e também resolve **entidades numéricas** como `é` (decimal) e `é` (hexadecimal), que apontam para pontos de código **Unicode**. ### ASCII / Binary O formato **ASCII / Binary** mostra cada byte como um bloco de **8 bits** (`01001000`), separados por espaço. Ao decodificar, o Decodificar exige blocos de exatamente 8 bits contendo só `0` e `1`, e reconstrói o texto a partir deles. ### Unicode e UTF-8 O Decodificar trata o texto como **UTF-8** em todas as conversões. Isso significa que caracteres acentuados, emojis e qualquer ponto de código Unicode **sobrevivem** ao codificar e decodificar Base64, Hex e Binary. Não há um botão "Unicode" separado: o suporte a Unicode é **intrínseco** ao módulo e, no caso de HTML Entities, aparece também na forma das entidades numéricas `&#...;` e `&#x...;`, que são resolvidas para o caractere Unicode correspondente. ### JWT (JSON Web Token) Um **JWT** tem três partes separadas por ponto: **header**, **payload** e **signature**, cada uma em Base64URL. O **header** diz o algoritmo (`alg`) e o tipo (`typ`); o **payload** carrega as claims (como `sub`, `exp`, `iat`); a **signature** garante a integridade. O **Inspetor de JWT** separa, decodifica e formata as duas primeiras partes como JSON, converte o `exp` em data legível e permite **remontar** o token após editar o payload. > [!IMPORTANTE] > O Decodificar lê o JWT **localmente** e **não valida a assinatura** — isso exigiria a chave ou o segredo. Ao editar o payload e remontar, a assinatura original é mantida, então o token reconstruído provavelmente ficará **inválido** para o servidor. ### Assinaturas JWT (famílias de algoritmo) O painel **JWT e assinaturas** lê o campo `alg` do header e classifica a assinatura em uma **família** e um **tipo**: - **HMAC (HS256/384/512)** — assinatura **simétrica**: o mesmo segredo compartilhado assina e valida. - **RSA (RS256/384/512)** — assinatura **assimétrica** com PKCS#1 v1.5: chave privada assina, pública valida. - **RSA-PSS (PS256/384/512)** — variante moderna do RSA com padding PSS, também assimétrica. - **ECDSA (ES256/384/512)** — curvas elípticas com par de chaves, assimétrica. - **EdDSA** — família moderna (normalmente Ed25519/Ed448), assimétrica. - **none** — header com `alg=none`: o token **não está assinado**. ### JWE (JSON Web Encryption) Um **JWE compacto** tem **cinco** segmentos: **protected header**, **encrypted key**, **initialization vector (IV)**, **ciphertext** e **authentication tag**. O **Inspetor de JWE** lê apenas o **protected header** (os metadados públicos do envelope) e identifica `alg` (gestão de chave), `enc` (criptografia do conteúdo), `zip`, `cty`, `typ` e `kid`. > [!AVISO] > O Inspetor de JWE **não descriptografa** o payload. Sem a chave correta, o conteúdo continua cifrado; o módulo só mostra o envelope. ### Hashes Um **hash** é uma impressão digital de tamanho fixo de um conteúdo. O Decodificar **gera** MD5, SHA-1, SHA-256 e SHA-512 a partir do texto (em bytes UTF-8) e também **identifica** um hash capturado pelo tamanho em caracteres hexadecimais: 32 (MD5), 40 (SHA-1), 64 (SHA-256) e 128 (SHA-512). Hash é um caminho só de ida: ele **não é reversível**. ### Smart Decode (autodetecção) O **Smart Decode** é a "mágica" do módulo: você cola um valor e ele **testa vários formatos automaticamente**, mostrando um cartão para cada detecção plausível. Ele reconhece **JWT**, **JWE**, **URL**, **Base64**, **Base64URL**, **Hex**, **HTML Entities** e **ASCII/Binary**, e só mostra um resultado quando ele é diferente da entrada e parece **legível** (acima de 85% de caracteres imprimíveis), evitando "lixo" na tela. ## A tela do Decodificar: página inicial, painéis e abas O Decodificar abre numa **página inicial** com o título `DECODIFICAR` e o resumo "Analise strings, tokens e hashes rapidamente". Dela saem seis entradas, cada uma com um ícone, uma descrição curta e um chip de resumo à direita. Toque em uma entrada para abrir a página correspondente; em cada página, o atalho **DECODIFICAR** no topo (com a seta) volta para o início. | Entrada | O que abre | Resumo exibido | | --- | --- | --- | | FORMATOS | Codificar e decodificar URL, Base64, Base64URL, Hex, HTML Entities e ASCII/Binary | O formato atual (ex.: `URL`) | | INSPETOR DE JWT | Separar header, payload e signature, converter `exp` e remontar o token | `JWT` | | JWT E ASSINATURAS | Classificar HS/HMAC, RS/RSA, PS/RSA-PSS, ES/ECDSA e simétrica vs. assimétrica | `HS / RS / ES` | | INSPETOR DE JWE | Ler o protected header e separar os 5 segmentos do JWE compacto | `JWE` | | HASHES E CRIPTO | Gerar MD5, SHA-1, SHA-256, SHA-512 e identificar hashes | O algoritmo atual (ex.: `SHA-256`) | | SMART DECODE | Autodetecção de JWT, Base64, URL, Hex, HTML Entities e Binary | `MÁGICA` | Cada página tem a mesma estrutura: um campo de **ENTRADA** para colar o valor, uma linha de **botões de ação** e um ou mais blocos de **RESULTADO**. Os blocos de resultado são **selecionáveis**: toque e segure para copiar ou para reenviar um trecho ao próprio Smart Decode. ## Opções do Decodificar e como configurar As opções do Decodificar ficam nas páginas **FORMATOS** e **HASHES E CRIPTO**. A tabela abaixo reúne todas. | Opção | Valores | Padrão | O que faz | | --- | --- | --- | --- | | Modo (FORMATOS) | DECODIFICAR, CODIFICAR | DECODIFICAR | Define o sentido da conversão para o formato selecionado | | Formato | URL, BASE64, BASE64URL, HEXADECIMAL, HTML ENTITIES, ASCII / BINARY | URL | Escolhe qual transformação será aplicada à entrada | | Algoritmo (HASHES) | MD5, SHA-1, SHA-256, SHA-512 | SHA-256 | Escolhe o algoritmo usado em GERAR HASH | Para **configurar os FORMATOS**, comece pelo **MODO**: deixe em **DECODIFICAR** para ler um valor capturado, ou troque para **CODIFICAR** quando quiser produzir um valor para reenviar. Em seguida, toque no chip do **FORMATO** desejado — a descrição logo abaixo explica o que aquele formato faz. Cole o conteúdo em **ENTRADA** e toque em **EXECUTAR**. O resultado aparece em **RESULTADO**; use **USAR SAÍDA** para jogar o resultado de volta na entrada e **encadear** conversões (por exemplo, decodificar Base64URL e depois ler o JSON). Para **configurar os HASHES**, toque no chip do **ALGORITMO** (MD5, SHA-1, SHA-256 ou SHA-512) antes de gerar. Cole o conteúdo em **ENTRADA** e use **GERAR HASH**. Se o que você colou já é um hash e você quer saber qual é, toque em **IDENTIFICAR**: o módulo olha o tamanho em caracteres hexadecimais e diz o tipo provável. > [!DICA] > O **algoritmo de hash** afeta apenas o botão **GERAR HASH**. O **IDENTIFICAR** funciona para qualquer hash hexadecimal, independentemente do algoritmo selecionado nos chips. ## Botões e ações Cada página tem seu próprio conjunto de botões. A tabela reúne o que cada um faz. | Botão | Página | O que faz | | --- | --- | --- | | EXECUTAR | Formatos | Aplica o formato e o modo atuais à entrada | | USAR SAÍDA | Formatos | Copia o resultado de volta para o campo de entrada | | COPIAR | Formatos | Copia o resultado para a área de transferência | | ANALISAR | Inspetor de JWT | Separa e decodifica header, payload e signature | | COPIAR TOKEN | Inspetor de JWT / JWE | Copia o token original da entrada | | REMONTAR TOKEN | Inspetor de JWT | Recria o token a partir do payload editado | | COPIAR REMONTADO | Inspetor de JWT | Copia o token reconstruído | | ANALISAR ASSINATURA | JWT e assinaturas | Classifica a família e o tipo da assinatura | | USAR TOKEN DO INSPETOR | JWT e assinaturas | Traz para cá o token já colado no Inspetor de JWT | | ANALISAR JWE | Inspetor de JWE | Separa os 5 segmentos e lê o protected header | | GERAR HASH | Hashes e cripto | Gera o hash da entrada no algoritmo escolhido | | IDENTIFICAR | Hashes e cripto | Diz o tipo provável de um hash pelo tamanho | | COPIAR HASH | Hashes e cripto | Copia o hash gerado | | MÁGICA | Smart Decode | Roda a autodetecção sobre a entrada | | LIMPAR | Smart Decode | Apaga a entrada e os resultados | | USAR COMO ENTRADA | Smart Decode | Usa o texto recebido do tráfego como entrada | | ABRIR JWT / ABRIR JWE | Smart Decode | Abre o token detectado no inspetor correspondente | ## Passo a passo ### 1. Decodificar um valor de formato simples 1. Na página inicial, abra **FORMATOS**. 2. Deixe o **MODO** em **DECODIFICAR**. 3. Escolha o **FORMATO** (por exemplo, **BASE64**). 4. Cole o valor em **ENTRADA** e toque em **EXECUTAR**. 5. Leia o **RESULTADO**. Se ele ainda estiver codificado em outro formato, toque em **USAR SAÍDA** e repita com o formato seguinte. ### 2. Codificar um valor para reenviar 1. Em **FORMATOS**, troque o **MODO** para **CODIFICAR**. 2. Escolha o formato de destino (por exemplo, **URL** para um parâmetro de query). 3. Digite ou cole o texto legível em **ENTRADA** e toque em **EXECUTAR**. 4. Use **COPIAR** e leve o valor para o [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir) ou o [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador). ### 3. Inspecionar e remontar um JWT 1. Abra o **INSPETOR DE JWT** e cole o token completo em **TOKEN JWT**. 2. Toque em **ANALISAR**. Veja a visualização colorida (HEADER, PAYLOAD, SIGNATURE), o **HEADER DECODED** e, se houver `exp`, o **TIMESTAMP exp** convertido para data local. 3. Edite o JSON em **PAYLOAD EDITÁVEL** se quiser testar uma variação. 4. Toque em **REMONTAR TOKEN** e depois em **COPIAR REMONTADO**. 5. Lembre-se: a assinatura antiga é mantida, então o token remontado tende a ser recusado pelo servidor que valida a assinatura. ### 4. Classificar a assinatura de um JWT 1. Abra **JWT E ASSINATURAS**. Se o token já está no Inspetor, toque em **USAR TOKEN DO INSPETOR**; senão, cole em **TOKEN JWT**. 2. Toque em **ANALISAR ASSINATURA**. 3. Leia o **RESUMO DA ASSINATURA** (`ALG`, `TIPO`, `FAMÍLIA`, `typ`) e a **CLASSIFICAÇÃO**, que explica o fluxo de chaves e lista os algoritmos da mesma família. ### 5. Ler o envelope de um JWE 1. Abra o **INSPETOR DE JWE** e cole o JWE compacto (5 segmentos) em **TOKEN JWE**. 2. Toque em **ANALISAR JWE**. 3. Veja o **RESUMO DO ENVELOPE** (`alg`, `enc`, `zip`, `cty`, `typ`, `kid`), a visualização dos 5 segmentos e o **PROTECTED HEADER DECODED**. ### 6. Gerar e identificar hashes 1. Abra **HASHES E CRIPTO**. 2. Para gerar: escolha o **ALGORITMO**, cole o conteúdo em **ENTRADA** e toque em **GERAR HASH**. Use **COPIAR HASH** para levar o valor adiante. 3. Para identificar: cole o hash em **ENTRADA** e toque em **IDENTIFICAR**. O módulo responde com o tipo provável pelo tamanho. ### 7. Colar ou enviar um valor vindo do tráfego 1. No [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador), no [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir) ou em qualquer texto selecionável do app, **selecione** o trecho. 2. No menu de seleção, toque em **DECODIFICAR** (ou use **Enviar para Decodificar**). O app mostra a mensagem "Análise enviada para o Decodificar". 3. O Decodificar abre o **SMART DECODE** com o trecho em **TEXTO RECEBIDO** e já roda a autodetecção. 4. Toque em **USAR COMO ENTRADA** para editar e reprocessar, ou em **ABRIR JWT** / **ABRIR JWE** quando um token for detectado. 5. No [Navegador](https://netcattest.com/catsuite/docs/modulos/navegador), use **Detectar JWT / Base64 em storage** para mandar tokens e valores do storage da página direto para cá. > [!DICA] > Se preferir, cole o valor manualmente na **ENTRADA MÁGICA** e toque em **MÁGICA**. O resultado é o mesmo da autodetecção vinda do tráfego. ## Exemplos Decodificação de URL (percent-encoding): ```text nome%3DCat%20Suite%26id%3D1024 ``` ```text nome=Cat Suite&id=1024 ``` Base64 e Base64URL com o mesmo conteúdo: ```text Q2F0U3VpdGU= ``` ```text CatSuite ``` Hexadecimal em bytes separados por espaço: ```text 48 65 78 ``` ```text Hex ``` Entidades HTML, incluindo uma entidade numérica Unicode: ```text <b>café</b> ``` ```text café ``` Blocos binários de 8 bits: ```text 01001000 01101001 ``` ```text Hi ``` JWT de exemplo e as duas primeiras partes decodificadas: ```text eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c ``` ```json { "alg": "HS256", "typ": "JWT" } ``` ```json { "sub": "1234567890", "name": "John Doe", "iat": 1516239022 } ``` Hashes do texto `CatSuite` em cada algoritmo: ```text MD5 08aa3451f325a5ffebb46df10aec9ecf SHA-1 30a1abc0a012cd7a49f469d698d7881df04b201e SHA-256 10f3dfd0bb7f1fb99bbe8fd16816ad6e5ca012be645c2a0660d50a45ecfb7961 SHA-512 1824976bbd707e6d646ff5fbb5ea3d9171d8ba3882d9ef6e81e84c34ea1a52f3ea097123e30420037917cd78bcd3df2f89cd794a3d9faa840330c5ca785aa58f ``` Identificação pelo tamanho em caracteres hexadecimais: ```text 32 caracteres -> MD5 40 caracteres -> SHA-1 64 caracteres -> SHA-256 128 caracteres -> SHA-512 ``` ## Problemas comuns e perguntas frequentes **Colei um Base64 e o resultado veio "sujo" ou vazio.** Pode ser **Base64URL** (com `-` e `_`), não Base64 padrão. Troque o formato para **BASE64URL**. Também confira se não há quebras de linha ou espaços colados junto; o módulo remove espaços, mas conteúdo cortado não decodifica. **O Hex não decodifica.** O decodificador de Hex precisa de um número **par** de dígitos hexadecimais. Caracteres fora de `0-9a-f` são ignorados, mas, se sobrar um dígito solto, a conversão falha. Cole os bytes completos. **O Binary deu erro.** Use blocos de exatamente **8 bits** contendo só `0` e `1`, separados por espaço. Qualquer outro caractere invalida a entrada. **O JWT não abre.** Um JWT precisa de pelo menos **header e payload** separados por ponto, e ambos devem ser JSON válido em Base64URL. Tokens truncados, com aspas a mais ou colados pela metade não passam. **Editei o payload e o token "quebrou".** É esperado. O Decodificar **mantém a assinatura original** ao remontar e **não assina** de novo (ele não tem a chave). O token remontado serve para estudo, não para enganar um servidor que valide a assinatura. **O JWE não mostra o conteúdo.** O Inspetor de JWE lê **apenas o envelope** (protected header e segmentos). O payload continua **cifrado**: sem a chave correta, não há como descriptografar. **O IDENTIFICAR disse que "o tamanho não bate".** O valor é hexadecimal, mas não tem 32, 40, 64 nem 128 caracteres. Pode ser um hash de outro algoritmo, um valor truncado ou algo que não é hash. **O Smart Decode não detectou nada.** Ele só mostra resultados **diferentes da entrada** e que pareçam **legíveis**. Um valor que já está em texto puro, ou que decodifica para bytes ilegíveis, não gera cartão. Tente o formato específico na página **FORMATOS**. > [!PERIGO] > O Decodificar nunca valida assinaturas nem descriptografa conteúdo protegido. Não trate um JWT lido aqui como "confiável" só porque o payload abriu: a leitura local **não prova** a autenticidade do token. ## Continue - [Navegador](https://netcattest.com/catsuite/docs/modulos/navegador) - [Interceptador](https://netcattest.com/catsuite/docs/modulos/interceptador) - [Repetir](https://netcattest.com/catsuite/docs/modulos/repetir) - [Intruso](https://netcattest.com/catsuite/docs/modulos/intruso) - [SSL/TLS](https://netcattest.com/catsuite/docs/modulos/ssl-tls) - [Segurança e uso responsável](https://netcattest.com/catsuite/docs/seguranca)