Skip to content

Criptografar e Descriptografar SM4 Online

Criptografe e descriptografe SM4 online. Se a descriptografia falhar, aponta se o erro é de modo, padding, IV ou codificação e dá a correção. Roda no navegador, sem upload. ECB, CBC, CTR, CFB, OFB; PKCS#7, zero ou sem padding.

Sem rastreamento Roda no navegador Grátis
A criptografia roda inteiramente no seu navegador — a chave e os dados que você informa nunca saem deste dispositivo.
Texto cifrado
Comando OpenSSL equivalente 
—

Requer OpenSSL 3. O comando contém a chave que você informou.

Vetores de teste SM4 da GB/T 32907-2016

Calculados durante o build pelo mesmo motor que esta página executa — confira sua própria implementação de SM4 com eles.
Chave 0123456789abcdeffedcba9876543210
Texto simples 0123456789abcdeffedcba9876543210
Texto cifrado, 1 criptografia 681edf34d206965e86b3e94f536e4246
Texto cifrado, 1.000.000 de criptografias 595298c7c6fd271f0402f804c33d3f66
O motor SM4 é testado com os dois vetores do Anexo A da GB/T 32907-2016 e comparado com o OpenSSL 3 em ECB, CBC, CTR, CFB e OFB. As configurações padrão das bibliotecas foram conferidas executando OpenSSL, Node.js, sm-crypto, gm-crypt, gmssl e duas bibliotecas Go, e lendo o código-fonte do Hutool e do BouncyCastle. — Equipe de Ferramentas de Segurança da Go Tools · Sep 11, 2026

Escrito e revisado por desenvolvedores que constroem ferramentas de criptografia. Cada texto cifrado e cada contagem de bytes citados nesta página são calculados pelo motor da ferramenta e verificados por testes.

Respostas rápidas sobre SM4

Tamanho da chave SM4

16 bytes Exatamente 128 bits: 16 bytes, escritos como 32 dígitos hex ou 16 caracteres ASCII. Não existem chaves SM4 de 192 ou 256 bits.

Vetor de teste GB/T 32907

681edf34d206965e86b3e94f536e4246 Com chave e texto simples 0123456789abcdeffedcba9876543210, uma criptografia dá 681edf34d206965e86b3e94f536e4246.

Tamanho de bloco e rodadas do SM4

32 rodadas Blocos de 16 bytes (128 bits), criptografados em 32 rodadas.

Um IV errado sempre gera erro no CBC?

primeiros 16 bytes Não. Só os primeiros 16 bytes descriptografam errado, e o padding do último bloco continua sendo validado.

O que é SM4?

SM4 é a cifra de bloco dos padrões chineses de criptografia comercial. Foi publicada como GM/T 0002-2012, tornou-se o padrão nacional GB/T 32907-2016 (em vigor desde 1º de março de 2017) e foi incluída no padrão internacional ISO/IEC 18033-3 por uma emenda em 2021. É uma cifra simétrica: a mesma chave de 128 bits criptografa e descriptografa, e ela trabalha com blocos de 128 bits, 16 bytes por vez — o mesmo tamanho de bloco do AES.

Internamente, cada bloco é dividido em quatro palavras de 32 bits e passa por 32 rodadas. Cada rodada combina três das palavras com uma chave de rodada, passa o resultado por uma S-box de 8 bits e por uma transformação linear, e o incorpora à quarta palavra. As 32 chaves de rodada são derivadas da chave com dois conjuntos fixos de constantes, e a descriptografia é o mesmo cálculo com as chaves de rodada em ordem inversa.

A cifra de bloco sozinha só processa exatamente 16 bytes, então dados reais sempre passam por um modo de operação. Esta ferramenta oferece os cinco clássicos: ECB e CBC, que trabalham com blocos inteiros e precisam de padding, e CTR, CFB e OFB, que transformam o SM4 em uma cifra de fluxo sem padding nenhum. A maioria das descriptografias que falham não tem nada a ver com o SM4 em si — elas vêm de os dois lados discordarem sobre o modo, o padding, o IV, a codificação do texto ou a forma como a string da chave vira bytes, e as bibliotecas não concordam nem sobre o que um "SM4" sozinho significa.

A Web Crypto API embutida nos navegadores não inclui SM4, então esta página traz sua própria implementação e a executa localmente. Ela é testada com os dois vetores de teste da GB/T 32907 e comparada com o OpenSSL 3 em todos os modos.

// SM4-CBC with PKCS#7 padding using Node.js and its bundled OpenSSL 3.
// Key and IV are both exactly 16 bytes (32 hex digits).
const crypto = require('node:crypto');

const key = Buffer.from('0123456789abcdeffedcba9876543210', 'hex');
const iv = Buffer.from('fedcba98765432100123456789abcdef', 'hex');

const cipher = crypto.createCipheriv('sm4-cbc', key, iv);
const ciphertext = Buffer.concat([cipher.update('hello', 'utf8'), cipher.final()]);
console.log(ciphertext.toString('base64')); // fUQPRg2HAXHGz5ZslzCpSQ==

const decipher = crypto.createDecipheriv('sm4-cbc', key, iv);
const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
console.log(plaintext.toString('utf8')); // hello

Recursos da ferramenta SM4

Diz por que a descriptografia falhou

Quando a descriptografia falha, a página testa de novo a codificação do texto cifrado, o formato da chave, o modo, o IV, o padding e a codificação do texto, e mostra as configurações que produzem texto legível.

Presets para os suspeitos de sempre

Um clique aplica os padrões do OpenSSL, Hutool, sm-crypto, gm-crypt ou tjfoc/gmsm — bibliotecas que não concordam nem sobre se um "SM4" simples significa ECB ou CBC.

Cinco modos, três paddings, UTF-8 ou GBK

ECB, CBC, CTR, CFB e OFB com PKCS#7, zero padding ou sem padding. O texto simples pode ser UTF-8 ou GBK, a codificação que código Java antigo produz no Windows em chinês. GCM não é suportado.

Chave e IV SM4: aleatórios ou em hex, texto ou Base64

Gere uma chave ou um IV aleatório de 16 bytes com um clique, ou informe-o do jeito que seu código o escreve. Um contador de bytes ao vivo confirma que você tem exatamente 16 bytes antes de sair atrás de outras causas.

Vetores de teste GB/T 32907 na página

Os dois resultados do Anexo A aparecem em uma tabela e podem ser carregados com um clique, para você conferir qualquer implementação de SM4 com o padrão.

Comando OpenSSL equivalente

Cada resultado vem com o comando openssl enc que o reproduz, para você confirmar no terminal ou repassar a um colega.

Roda inteiramente no seu navegador

O motor SM4 roda localmente. Chaves e dados nunca saem da página, e a ferramenta continua funcionando offline.

Configurações padrão do SM4 nas bibliotecas mais usadas

OpenSSL 3 (openssl enc)

-sm4 = CBC

-sm4 é um alias de -sm4-cbc. -K e -iv recebem hex, o PKCS#7 fica ligado a menos que você passe -nopad, e a saída sai em bytes brutos a menos que você adicione -base64 -A. Um -K com tamanho errado é truncado ou completado com zeros com apenas um aviso.

Java: Hutool SmUtil.sm4(key)

ECB · PKCS#7

O Hutool passa só SM4, que o BouncyCastle executa como ECB com PKCS#7 (o JCE chama esse padding de PKCS5Padding). Os métodos de string usam UTF-8 e encryptHex imprime hex minúsculo. Para CBC, use new SM4(Mode.CBC, Padding.PKCS5Padding, key, iv).

Java: BouncyCastle Cipher.getInstance("SM4")

ECB · PKCS#7

Em um modo que precisa de IV mas não recebe nenhum, a criptografia gera silenciosamente um IV aleatório e a descriptografia lança no IV set when one expected — então um texto cifrado criptografado sem guardar esse IV não pode ser descriptografado em lugar nenhum.

JavaScript: sm-crypto

ECB · chave hex

sm4.encrypt(data, key) usa por padrão ECB com PKCS#7, espera a chave como string hex de 32 dígitos e devolve hex minúsculo. Só mode: 'cbc' muda o modo; qualquer outro valor continua silenciosamente em ECB. O sm-crypto-v2 se comporta igual, mas usa um IV todo zerado quando o CBC não recebe iv.

JavaScript: gm-crypt

CBC · chave em texto · Base64

Usa CBC por padrão, recebe a chave e o IV como strings UTF-8 de 16 caracteres e devolve Base64. Uma chave cujos bytes não são UTF-8 válido simplesmente não pode ser passada para ele.

Python: gmssl CryptSM4

PKCS#7 · chave cortada em 16 bytes

Você escolhe o modo chamando crypt_ecb ou crypt_cbc. set_key lê só os primeiros 16 bytes, então uma chave mais longa é cortada silenciosamente, e uma chave errada normalmente devolve bytes vazios em vez de um erro.

Go: tjfoc/gmsm sm4

IV zerado por padrão

Sm4Cbc usa um IV no nível do pacote que fica todo zerado até SetIV ser chamado, aplica padding PKCS#7 mesmo em CFB e OFB e descarta erros na remoção do padding — uma chave errada devolve nil sem erro.

Exemplos de criptografia e descriptografia SM4

Vetor de teste GB/T 32907 (ECB, sem padding)

Chave 0123456789abcdeffedcba9876543210, texto simples (hex) 0123456789abcdeffedcba9876543210
681edf34d206965e86b3e94f536e4246

Este é o exemplo 1 do Anexo A da GB/T 32907-2016: a chave e o texto simples são o mesmo valor de 128 bits, e uma criptografia dá 681edf34d206965e86b3e94f536e4246. Criptografando essa saída de novo, um milhão de vezes no total, chega-se a 595298c7c6fd271f0402f804c33d3f66. Os dois valores aparecem na tabela de vetores de teste desta página, calculados pelo mesmo motor que você está usando. O botão Vetor de teste GB/T 32907 carrega o primeiro.

CBC com PKCS#7: texto na entrada, Base64 na saída

Chave 0123456789abcdeffedcba9876543210, IV fedcba98765432100123456789abcdef, texto simples: SM4 interop test: order 20260911-0042
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y

O texto simples tem 37 bytes em UTF-8. O PKCS#7 o completa até 48 bytes, três blocos de 16 bytes, que o Base64 escreve com 64 caracteres. O botão Carregar exemplo preenche exatamente esses valores, e o painel do OpenSSL mostra um comando que reproduz a mesma string Base64 no terminal.

IV errado no CBC: só os primeiros 16 bytes quebram

O texto cifrado acima, descriptografado com o IV 00000000000000000000000000000000
16 bytes de lixo, depois ": order 20260911-0042"

O CBC mistura o IV apenas no primeiro bloco, e o padding PKCS#7 fica no último bloco, então a verificação de padding continua passando e o OpenSSL não gera nenhum erro. Esta página percebe que o primeiro bloco está ilegível e avisa que a chave e o modo estão certos e o problema é o IV — ou que os primeiros 16 bytes do texto cifrado são, eles mesmos, o IV.

Como usar a ferramenta de criptografia e descriptografia SM4

  1. 1

    Escolha um preset de biblioteca, ou o modo e o padding

    Se você conhece a biblioteca do outro lado, selecione-a em “Usar os padrões de”. Caso contrário, selecione “Criptografar” ou “Descriptografar” e ajuste o modo e o padding. Os modos de fluxo (CTR, CFB, OFB) não têm padding, então o seletor de padding fica desativado para eles.

  2. 2

    Informe a chave e o IV

    Os dois têm exatamente 16 bytes. Escolha o formato em que a string está escrita — hex, texto ou Base64 — e veja o contador de bytes ficar verde. Os botões “Aleatório” geram valores novos.

  3. 3

    Cole a entrada

    Para criptografar, digite texto (UTF-8 ou GBK) ou cole bytes em hex. Para descriptografar, cole o texto cifrado e indique se ele está em Base64 ou hex. O resultado é atualizado enquanto você digita.

  4. 4

    Copie o resultado ou confira a ida e volta

    Copie a saída, ou clique em “Descriptografar este texto cifrado” para levá-la à aba de descriptografia com a mesma chave e o mesmo IV. O painel do OpenSSL mostra um comando que reproduz o resultado.

  5. 5

    Se a descriptografia falhar, leia o diagnóstico

    O diagnóstico lista as configurações com as quais suas entradas resultam em texto legível. Aplique uma com um clique, ou leia a nota se só os primeiros 16 bytes falharem — isso aponta para o IV.

Por que a descriptografia SM4 falha

Ler uma chave hex como texto

Uma string hex de 32 caracteres só tem 16 bytes quando é decodificada como hex. Lida como texto, ela tem 32 bytes, o que o SM4 rejeita — ou, em código que corta ou completa chaves silenciosamente, vira outra chave completamente diferente.

✗ Incorreto 
Chave (texto): 0123456789abcdeffedcba9876543210  -> 32 bytes, rejeitada
✓ Correto 
Chave (hex):   0123456789abcdeffedcba9876543210  -> 16 bytes

Descriptografar texto cifrado CBC como ECB

Os dois lados precisam usar o mesmo modo. Texto cifrado CBC descriptografado como ECB dá lixo em todos os blocos e normalmente falha na verificação de padding no final.

✗ Incorreto 
criptografar:    SM4/CBC/PKCS5Padding
descriptografar: SM4/ECB/PKCS5Padding  -> bad decrypt
✓ Correto 
criptografar:    SM4/CBC/PKCS5Padding
descriptografar: SM4/CBC/PKCS5Padding, mesmo IV

Usar um IV diferente

No CBC, um IV errado não gera erro: os primeiros 16 bytes saem embaralhados e o resto descriptografa normalmente. Se só o começo do seu texto simples está quebrado, compare os IVs.

✗ Incorreto 
IV na descriptografia 00000000000000000000000000000000
-> 16 bytes de lixo + ": order 20260911-0042"
✓ Correto 
IV na descriptografia fedcba98765432100123456789abcdef
-> "SM4 interop test: order 20260911-0042"

Tratar texto cifrado Base64 como hex

Base64 e hex são duas formas de escrever os mesmos bytes. Ler um como se fosse o outro entrega à cifra a entrada errada desde o início.

✗ Incorreto 
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y  lido como hex -> inválido
✓ Correto 
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y  lido como Base64 -> 48 bytes

Zero padding apagando zeros reais do final

O zero padding não distingue padding de dados, então um texto simples que realmente termina em 0x00 perde esses bytes. Use PKCS#7 para qualquer coisa que não seja texto puro.

✗ Incorreto 
zero padding: 61 62 00  -> descriptografa para 61 62
✓ Correto 
PKCS#7:       61 62 00  -> descriptografa para 61 62 00

Supor que "SM4" significa o mesmo modo em todo lugar

O OpenSSL trata sm4 como CBC. O BouncyCastle — e, portanto, o SmUtil.sm4(key) do Hutool — trata SM4 como ECB com PKCS#7. Dois sistemas que "só usam SM4" podem discordar sobre o modo.

✗ Incorreto 
Java:    Cipher.getInstance("SM4")  -> ECB + PKCS#7
OpenSSL: openssl enc -sm4           -> CBC
✓ Correto 
Java:    Cipher.getInstance("SM4/CBC/PKCS5Padding")
OpenSSL: openssl enc -sm4-cbc

Criptografar bytes GBK de um lado e UTF-8 do outro

O getBytes() do Java sem charset usa o padrão da plataforma, que é GBK em um JDK 17 ou anterior no Windows em chinês. O mesmo texto em chinês então vira um texto cifrado diferente, e o outro lado o descriptografa como caracteres corrompidos (mojibake).

✗ Incorreto 
"国密SM4 test".getBytes()  // GBK em JDK <= 17 no Windows em chinês
-> texto cifrado ECB 3188d06cf28db70092f8753cbd5ee518
✓ Correto 
"国密SM4 test".getBytes(StandardCharsets.UTF_8)
-> texto cifrado ECB d830308b0ae4fa7b9a2b5d59f7f65ca5

Quando você precisa de criptografia SM4 online

Igualar a saída SM4 entre backend e frontend
Seu serviço Java e seu cliente web produzem textos cifrados diferentes para o mesmo texto. Reproduza cada lado aqui com o preset da sua biblioteca e veja qual parâmetro difere.
Depurar texto cifrado de um parceiro que não descriptografa
Um parceiro envia texto cifrado SM4 que não descriptografa. Cole-o com a chave e o IV combinados e deixe o diagnóstico encontrar o modo, o padding ou a codificação que ele realmente usou.
Validar uma implementação de SM4
Rode seu código com os vetores GB/T 32907 desta página e depois compare uma ida e volta em CBC, antes que a implementação chegue perto de dados de produção.
Preparar dados de teste para migrar para SM4
Quando um sistema migra de AES para SM4, gere aqui trios conhecidos de chave, IV e texto cifrado para usar como fixtures nos novos testes.
Ver como os modos de cifra de bloco se comportam
Criptografe dois blocos idênticos em ECB e em CBC, ou descriptografe com um IV errado, e observe o que muda no texto cifrado e na saída.

Como funcionam o SM4 e seus modos

Tamanho de bloco, tamanho de chave e rodadas
O SM4 criptografa blocos de 128 bits com uma chave de 128 bits em 32 rodadas. Cada rodada aplica uma S-box de 8 bits a uma palavra de 32 bits e depois uma transformação linear que faz XOR da palavra com quatro rotações dela mesma. A descriptografia executa as mesmas 32 rodadas com as chaves de rodada em ordem inversa.
ECB: cada bloco por conta própria
O ECB criptografa cada bloco de 16 bytes de forma independente. Não precisa de IV, mas blocos iguais de texto simples viram blocos iguais de texto cifrado, então os padrões dos dados continuam visíveis. Precisa de padding, a menos que a entrada seja múltiplo de 16 bytes.
CBC: blocos encadeados e um IV
O CBC faz XOR de cada bloco de texto simples com o bloco cifrado anterior antes de criptografar, e usa o IV no primeiro bloco. Como o IV só entra no primeiro bloco, um IV errado corrompe exatamente os primeiros 16 bytes do texto simples e deixa intacto o padding do último bloco, então muitas vezes não aparece erro nenhum.
CTR, CFB e OFB: o SM4 como cifra de fluxo
Esses modos criptografam um contador ou um valor de realimentação e fazem XOR do resultado com os dados, então o texto cifrado tem o mesmo tamanho do texto simples e não há padding. No CTR, o IV inteiro de 16 bytes é incrementado como um único contador big-endian de 128 bits, igual ao OpenSSL. Um IV errado embaralha a mensagem inteira em CTR e OFB, mas só o primeiro bloco em CFB.
Regras de padding
O PKCS#7 adiciona de 1 a 16 bytes de valor n, então uma mensagem que já é um número inteiro de blocos ainda recebe um bloco inteiro de padding. O zero padding adiciona bytes 0x00 só quando necessário e remove todos os zeros do final ao descriptografar. Sem padding, os dados ficam como estão e entradas que não completam blocos inteiros são rejeitadas.

Boas práticas de criptografia SM4

Não escolha ECB em projetos novos
O ECB revela quais blocos são iguais. Use CBC ou CTR, a menos que precise se alinhar a um sistema existente que já usa ECB.
Use um IV aleatório novo para cada mensagem
O IV não é secreto, mas não pode se repetir com a mesma chave. Gere-o aleatoriamente para cada mensagem e guarde-o ou envie-o junto com o texto cifrado.
Autentique o texto cifrado
A GB/T 17964-2021, norma chinesa sobre modos de cifra de bloco, afirma que os modos que ela descreve protegem a confidencialidade, não a integridade. No CBC, alterar um byte do IV transforma pay=100.00 em pay=900.00 e a descriptografia continua dando certo. Calcule um MAC sobre o IV e o texto cifrado e verifique-o antes de descriptografar, por exemplo com o gerador de HMAC.
Escreva cada parâmetro na especificação da interface
"Criptografado com SM4" não é uma especificação. Registre o modo, o padding, como a chave e o IV são codificados, o conjunto de caracteres do texto simples e se o texto cifrado está em hex ou Base64.
Mantenha chaves reais longe de páginas web e do código-fonte
Use esta página com chaves de teste. Chaves de produção pertencem a um sistema de gerenciamento de chaves ou a um módulo de segurança de hardware (HSM), carregadas em tempo de execução em vez de coladas em formulários ou gravadas no repositório.

Perguntas frequentes sobre criptografia SM4

Por que minha descriptografia SM4 falha com erro de padding ou texto embaralhado?
A descriptografia só funciona quando tudo corresponde ao lado que criptografou: os bytes da chave, o modo, o IV, o padding e a forma como o texto cifrado foi escrito (hex ou Base64). O erro que você recebe — "bad decrypt", uma exceção de padding ou uma tela cheia de lixo — não diz qual deles está errado, e algumas bibliotecas devolvem uma saída vazia em vez de qualquer erro. Cole aqui o texto cifrado, a chave e o IV mesmo assim. Quando a descriptografia falha, a página testa todas as combinações de codificação do texto cifrado, formato da chave, modo, IV e padding — inclusive chaves que uma biblioteca cortou silenciosamente para 16 bytes e texto simples codificado em GBK — e lista as leituras que produzem texto legível, marcando aquelas cujo padding PKCS#7 foi validado. Se só os primeiros 16 bytes saírem errados, a chave e o modo estão certos e o IV não.
Qual é o tamanho de uma chave SM4, e ela pode ter 256 bits?
Uma chave SM4 tem exatamente 128 bits, ou 16 bytes — o mesmo tamanho do bloco. A GB/T 32907 define só esse tamanho de chave; não existe SM4 de 192 ou 256 bits. Se alguém pedir uma chave SM4 de 256 bits, verifique se uma string hex de 32 dígitos foi contada como 32 caracteres de 8 bits cada. Dezesseis bytes podem ser escritos como 32 dígitos hex ou como 16 caracteres ASCII, e confundir as duas formas é o erro de chave mais comum: 0123456789abcdeffedcba9876543210 lida como hex tem 16 bytes, mas a mesma string lida como texto tem 32 bytes e é rejeitada. O seletor de formato e o contador de bytes ao lado do campo da chave existem justamente para pegar isso.
O que é o IV do SM4, e qual tamanho ele deve ter?
O IV (vetor de inicialização) é um valor de 16 bytes misturado ao primeiro bloco em CBC, CTR, CFB e OFB; o ECB não usa IV. Ele precisa ter exatamente 16 bytes — 32 dígitos hex ou 16 caracteres ASCII —, então, se aparecer um erro de tamanho de IV, verifique se uma string hex de 32 dígitos foi lida como 32 bytes de texto. O IV não é secreto, mas não pode se repetir com a mesma chave: gere-o aleatoriamente e envie-o junto com o texto cifrado, muitas vezes na frente dele. Um IV errado no CBC normalmente não gera erro e só embaralha os primeiros 16 bytes. Algumas bibliotecas usam silenciosamente um IV todo zerado quando nenhum é informado (sm-crypto-v2, tjfoc/gmsm do Go), enquanto o BouncyCastle do Java gera um aleatório — se esse IV não for guardado com o texto cifrado, ninguém consegue descriptografá-lo.
Qual é a diferença entre SM4 ECB e CBC, e qual devo usar?
Use CBC (ou CTR) com um IV aleatório novo para cada mensagem. O ECB transforma blocos iguais de 16 bytes em blocos cifrados iguais, então a estrutura repetida dos dados aparece no texto cifrado. Escolha ECB apenas para conversar com um sistema que já o usa. Observe que nenhum dos dois modos detecta adulteração: se isso importa, envie também um MAC calculado sobre o IV e o texto cifrado, por exemplo com o gerador de HMAC.
Qual padding usar no SM4: PKCS5Padding, PKCS#7, zero padding ou sem padding?
O PKCS#7 sempre acrescenta de 1 a 16 bytes, cada um contendo o número de bytes adicionados, então quem recebe consegue removê-lo sem ambiguidade. Para uma cifra de bloco de 16 bytes como o SM4, o PKCS5Padding do Java é o mesmo padding — o BouncyCastle manda os dois nomes para o mesmo trecho de código. O zero padding acrescenta 0x00 só até o próximo limite de bloco. Na descriptografia, o Hutool e o BouncyCastle removem todos os 0x00 do final, inclusive bytes zero que faziam parte dos dados, enquanto o gmssl do Python remove só um. Sem padding, a entrada precisa ser um número inteiro de blocos de 16 bytes. CTR, CFB e OFB são modos de fluxo e nunca usam padding. Se o texto descriptografado termina com espaços estranhos, quadradinhos ou quebras de linha, o padding não foi removido: dados com PKCS#7 descriptografados sem padding mantêm n bytes de valor n no final (0x09, 0x0A e 0x0D aparecem como tabulações e quebras de linha); mude a saída para Hex e olhe o último bloco.
Qual é o tamanho do texto cifrado SM4, e dá para saber o modo por ele?
Conte em bytes. Com PKCS#7 em ECB ou CBC, o texto simples é arredondado para o próximo múltiplo de 16, e uma mensagem que já é múltiplo de 16 ganha mais um bloco inteiro — 5 ou 15 bytes viram 16, e 16 bytes viram 32. O zero padding só completa até o próximo múltiplo de 16, sem padding o tamanho se mantém, e o texto cifrado em CTR, CFB e OFB tem exatamente o tamanho do texto simples. O hex dobra a contagem de bytes; o Base64 usa 4 × ⌈bytes / 3⌉ caracteres, então 16 bytes viram 24 caracteres, 32 viram 44 e 64 viram 88. Some 16 bytes se o IV vier na frente. O texto cifrado sozinho não revela o modo, mas duas pistas ajudam: um tamanho que não é múltiplo de 16 praticamente descarta ECB ou CBC com padding, e dois blocos idênticos de 16 bytes apontam para ECB. Na dúvida, cole-o na aba de descriptografia e o diagnóstico automático testa os modos para você.
O SM4 gera sempre o mesmo texto cifrado, e por que o de outra ferramenta é diferente?
O ECB — ou qualquer modo com IV fixo — gera sempre o mesmo texto cifrado para a mesma chave e o mesmo texto simples; com um IV aleatório novo a cada execução, a saída muda toda vez, como deve ser. Fora isso, compare o modo, o padding, se a chave foi lida como hex ou como texto, como o texto simples foi codificado — UTF-8 na maior parte do código, mas GBK quando código Java antigo chama getBytes() em um Windows em chinês — e como o resultado é impresso: Base64, hex minúsculo ou hex maiúsculo. Com configurações idênticas e IV fixo, duas implementações corretas produzem saídas idênticas. Se você desconfia de uma das ferramentas, confira as duas primeiro com o vetor de teste GB/T 32907.
Como verifico se minha própria implementação de SM4 está correta?
Comece pelos dois vetores do Anexo A da GB/T 32907-2016. Com chave e texto simples ambos 0123456789abcdeffedcba9876543210, uma criptografia deve dar 681edf34d206965e86b3e94f536e4246, e um milhão de criptografias encadeadas, 595298c7c6fd271f0402f804c33d3f66. Esses vetores testam só a cifra de bloco; em seguida, criptografe algum texto em CBC com chave e IV fixos e compare com esta página ou com o comando OpenSSL que ela mostra. O motor por trás desta página é testado com os dois vetores e contra o OpenSSL 3 nos cinco modos.
O OpenSSL consegue criptografar e descriptografar SM4?
Sim. O OpenSSL 3 inclui SM4 em ECB, CBC, CFB, OFB e CTR. Use openssl enc -sm4-cbc -K <32 hex digits> -iv <32 hex digits>: -K recebe a chave bruta em hex, então nenhuma senha entra em jogo, -nopad desliga o PKCS#7 e -base64 -A lê ou escreve Base64 em uma única linha. Fique atento a duas coisas: -sm4 sozinho significa CBC, e um valor de -K com tamanho errado é truncado ou completado com zeros com apenas um aviso. O painel do OpenSSL nesta página monta o comando a partir das suas configurações atuais; o openssl enc não tem zero padding, então o painel avisa isso em vez de imprimir um comando que não daria o mesmo resultado.
Como descriptografo texto cifrado SM4 vindo do Java (Hutool) ou do JavaScript (sm-crypto)?
Primeiro descubra qual modo e qual padding o outro lado realmente usa — muitas vezes o código não diz. O SmUtil.sm4(key) do Hutool passa só o nome SM4, e o BouncyCastle completa com ECB com PKCS#7 (o PKCS5Padding do Java); só uma string completa como SM4/CBC/PKCS5Padding significa CBC. No JavaScript, o sm-crypto também usa ECB por padrão, recebe a chave como string hex de 32 dígitos e imprime hex minúsculo, enquanto o gm-crypt usa CBC por padrão, recebe uma chave em texto de 16 caracteres e imprime Base64. Depois, confira o charset do texto simples: os métodos de string do Hutool sempre usam UTF-8, mas um getBytes() sem argumento no JDK 17 ou anterior, em um Windows em chinês, pode significar GBK, o que muda o texto cifrado. Escolha a biblioteca em Usar os padrões de para definir tudo isso com um clique, ou informe os valores você mesmo; se algum deles for incerto, cole o texto cifrado assim mesmo e o diagnóstico automático testa as combinações de modo, padding, IV e codificação.
O SM4 é seguro, e meus dados são enviados?
Como algoritmo, o SM4 usa chave de 128 bits e 32 rodadas; a RFC 8998 (2021) afirma que, quando foi escrita, não se conheciam chaves fracas nem problemas de segurança no SM4. Os riscos práticos vêm da forma de uso: o ECB deixa vazar padrões e o CBC não detecta adulteração. Quanto a esta página, nada é enviado. Os navegadores não trazem SM4, então esta página carrega sua própria implementação de SM4 e a executa localmente; você pode abrir o painel de rede e ver que nenhuma requisição sai, ou desconectar e continuar usando a ferramenta. Isso a torna adequada para dados de teste, depuração e aprendizado. Mas não faz de uma página web o lugar certo para chaves de produção: elas pertencem a um sistema de gerenciamento de chaves ou a um módulo de hardware, não a uma caixa de texto de qualquer site.
Qual é a diferença entre SM4 e AES?
Os dois são cifras de bloco com blocos de 128 bits, e os modos e o padding funcionam do mesmo jeito em ambos — por isso os bugs de interoperabilidade do SM4 se parecem exatamente com os do AES. O SM4 faz 32 rodadas e tem um único tamanho de chave, 128 bits; o AES-128 faz 10 rodadas, e o AES também tem chaves de 192 e 256 bits. O SM4 é o padrão nacional chinês GB/T 32907-2016 e, desde 2021, faz parte do padrão internacional ISO/IEC 18033-3 ao lado do AES; é usado onde a criptografia comercial chinesa é exigida. O AES é o padrão FIPS 197 do NIST. Para AES, use a ferramenta de criptografia AES.

Ferramentas relacionadas

Ver todas as ferramentas →

Ferramenta de Descriptografia AES — OpenSSL e CryptoJS

Ferramentas de Segurança

Descriptografe AES online — GCM/CBC/CTR, frase-senha ou chave bruta, detecta automaticamente o formato "U2FsdGVkX1" do OpenSSL e CryptoJS. 100% no navegador, as chaves nunca saem da página.

Ferramenta de Criptografia AES — GCM, CBC e CTR

Ferramentas de Segurança

Criptografia AES online e gratuita — AES-128/192/256, GCM/CBC/CTR, frase-senha (PBKDF2) ou chave bruta. Roda 100% no navegador; nada é enviado a um servidor.

Gerador e Verificador de Hash Bcrypt

Ferramentas de Segurança

Gere e verifique hashes bcrypt de senha online — custo ajustável, prefixos $2b$/$2a$/$2y$. 100% no seu navegador; sua senha nunca é enviada.

Calculadora de soma de verificação CRC

Ferramentas de Segurança

Cole hex ou texto e veja de uma vez as 63 variantes de CRC-8, CRC-16 e CRC-32. Checksum que não bate? Digite o valor e a ferramenta diz qual é a variante — MODBUS, CCITT-FALSE, XMODEM, KERMIT. Tudo roda no seu navegador.

Gerador de HMAC e Verificador de Assinatura

Ferramentas de Segurança

Gerador e verificador de HMAC online e gratuito. Calcule HMAC-SHA256/SHA1/SHA384/SHA512 com chaves em Texto, Hex ou Base64 e saída Hex/Base64/Base64URL. 100% no seu navegador — as chaves nunca saem da página.

Decodificador JWT

Ferramentas de Segurança

Decodifique tokens JWT online com nosso decodificador JWT grátis. Inspecione cabeçalho, carga útil, assinatura, expiração e reivindicações. 100% navegador — seu token nunca sai do dispositivo. Sem cadastro, sem rastreio.