Skip to content

Cifratura e decifratura SM4 online

Cifra e decifra SM4 online. Se la decifratura fallisce, individua se sono errati modalità, padding, IV o codifica e propone la correzione. Gira nel browser, nessun upload. ECB, CBC, CTR, CFB, OFB; PKCS#7, zero o nessun padding.

Niente tracciamento Funziona nel browser Gratuito
La cifratura avviene interamente nel tuo browser: la chiave e i dati che inserisci non lasciano mai questo dispositivo.
Testo cifrato
Comando OpenSSL equivalente 
—

Richiede OpenSSL 3. Il comando contiene la chiave che hai inserito.

Vettori di test SM4 da GB/T 32907-2016

Calcolati in fase di build dallo stesso motore che usa questa pagina: confrontali con la tua implementazione di SM4.
Chiave 0123456789abcdeffedcba9876543210
Testo in chiaro 0123456789abcdeffedcba9876543210
Testo cifrato, 1 cifratura 681edf34d206965e86b3e94f536e4246
Testo cifrato, 1.000.000 di cifrature 595298c7c6fd271f0402f804c33d3f66
Il motore SM4 è testato su entrambi i vettori dell'Appendice A di GB/T 32907-2016 e confrontato con OpenSSL 3 in ECB, CBC, CTR, CFB e OFB. I valori predefiniti delle librerie sono stati verificati eseguendo OpenSSL, Node.js, sm-crypto, gm-crypt, gmssl e due librerie Go, e leggendo il codice sorgente di Hutool e BouncyCastle. — Go Tools Security Team · Sep 11, 2026

Scritto e revisionato da sviluppatori che realizzano strumenti crittografici. Ogni testo cifrato e ogni conteggio di byte citati in questa pagina sono calcolati dal motore dello strumento e verificati da test automatici.

Risposte rapide su SM4

Lunghezza della chiave SM4

16 byte Esattamente 128 bit: 16 byte, scritti come 32 cifre hex o 16 caratteri ASCII. Non esistono chiavi SM4 a 192 o 256 bit.

Vettore di test GB/T 32907

681edf34d206965e86b3e94f536e4246 Con chiave e testo in chiaro 0123456789abcdeffedcba9876543210, una cifratura dà 681edf34d206965e86b3e94f536e4246.

Dimensione del blocco e round di SM4

32 round Blocchi da 16 byte (128 bit), cifrati in 32 round.

In CBC un IV sbagliato causa sempre un errore?

primi 16 byte No. Si decifrano male solo i primi 16 byte, e il padding nell'ultimo blocco risulta comunque valido.

Cos'è SM4?

SM4 è il cifrario a blocchi degli standard cinesi di crittografia commerciale. È stato pubblicato come GM/T 0002-2012, è diventato lo standard nazionale GB/T 32907-2016 (in vigore dal 1° marzo 2017) ed è stato aggiunto allo standard internazionale ISO/IEC 18033-3 con un emendamento nel 2021. È un cifrario simmetrico: la stessa chiave a 128 bit cifra e decifra, e lavora su blocchi da 128 bit, 16 byte alla volta, la stessa dimensione di blocco di AES.

All'interno, ogni blocco viene diviso in quattro parole da 32 bit e attraversa 32 round. Ogni round combina tre delle parole con una chiave di round, passa il risultato attraverso una S-box a 8 bit e una trasformazione lineare, e lo combina con la quarta parola. Le 32 chiavi di round si ricavano dalla chiave con due insiemi fissi di costanti, e la decifratura è lo stesso calcolo con le chiavi di round in ordine inverso.

Il cifrario a blocchi da solo sa gestire soltanto blocchi di esattamente 16 byte, quindi i dati reali passano sempre attraverso una modalità operativa. Questo strumento offre le cinque classiche: ECB e CBC, che lavorano su blocchi interi e richiedono padding, e CTR, CFB e OFB, che trasformano SM4 in un cifrario a flusso senza alcun padding. La maggior parte delle decifrature fallite non ha niente a che fare con SM4 in sé: nasce dal disaccordo tra le due parti su modalità, padding, IV, codifica del testo o sul modo in cui la stringa della chiave diventa byte, e le librerie non concordano nemmeno su cosa significhi "SM4" scritto da solo.

La Web Crypto API integrata nei browser non include SM4, quindi questa pagina porta con sé una propria implementazione e la esegue in locale. È testata sui due vettori di test di GB/T 32907 e confrontata con OpenSSL 3 in ogni modalità.

// 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

Funzionalità dello strumento SM4

Ti dice perché la decifratura è fallita

Quando la decifratura fallisce, la pagina riprova codifica del testo cifrato, formato della chiave, modalità, IV, padding e codifica del testo, e mostra le impostazioni che producono testo leggibile.

Preset per le librerie che creano più problemi

Un clic imposta i valori predefiniti di OpenSSL, Hutool, sm-crypto, gm-crypt o tjfoc/gmsm, librerie che non concordano nemmeno sul fatto che "SM4" da solo significhi ECB o CBC.

Cinque modalità, tre padding, UTF-8 o GBK

ECB, CBC, CTR, CFB e OFB con PKCS#7, zero padding o nessun padding. Il testo in chiaro può essere UTF-8 o GBK, la codifica che il vecchio codice Java produce su Windows in cinese. GCM non è supportato.

Chiave e IV SM4: casuali, oppure in hex, testo o Base64

Genera con un clic una chiave o un IV casuale da 16 byte, oppure inseriscilo così come lo scrive il tuo codice. Un contatore di byte in tempo reale conferma che hai esattamente 16 byte, prima di andare a caccia di altre cause.

Vettori di test GB/T 32907 nella pagina

Entrambi i risultati dell'Appendice A sono riportati in una tabella e si caricano con un clic, così puoi verificare qualsiasi implementazione di SM4 rispetto allo standard.

Comando OpenSSL equivalente

Ogni risultato è accompagnato dal comando openssl enc che lo riproduce, così puoi confermarlo in un terminale o passarlo a un collega.

Funziona interamente nel tuo browser

Il motore SM4 gira in locale. Chiavi e dati non lasciano mai la pagina, e lo strumento continua a funzionare anche offline.

Valori predefiniti di SM4 nelle librerie più diffuse

OpenSSL 3 (openssl enc)

-sm4 = CBC

-sm4 è un alias di -sm4-cbc. -K e -iv accettano hex, PKCS#7 resta attivo a meno che tu non passi -nopad, e l'output è in byte grezzi a meno che tu non aggiunga -base64 -A. Un -K della lunghezza sbagliata viene troncato o completato con zeri, con un semplice avviso.

Java: Hutool SmUtil.sm4(key)

ECB · PKCS#7

Hutool passa un SM4 senza altre indicazioni, che BouncyCastle esegue come ECB con PKCS#7 (JCE lo chiama PKCS5Padding). I metodi stringa usano UTF-8 e encryptHex stampa hex minuscolo. Per CBC, usa new SM4(Mode.CBC, Padding.PKCS5Padding, key, iv).

Java: BouncyCastle Cipher.getInstance("SM4")

ECB · PKCS#7

In una modalità che richiede un IV ma non lo riceve, la cifratura genera in silenzio un IV casuale e la decifratura lancia no IV set when one expected: un testo cifrato prodotto senza salvare quell'IV non si può più decifrare da nessuna parte.

JavaScript: sm-crypto

ECB · chiave hex

sm4.encrypt(data, key) usa come predefinito ECB con PKCS#7, si aspetta la chiave come stringa hex di 32 cifre e restituisce hex minuscolo. Solo mode: 'cbc' cambia la modalità; qualsiasi altro valore resta ECB senza avvisi. sm-crypto-v2 si comporta allo stesso modo, ma usa un IV tutto a zero quando CBC non riceve iv.

JavaScript: gm-crypt

CBC · chiave testuale · Base64

Usa CBC come predefinito, accetta chiave e IV come stringhe UTF-8 di 16 caratteri e restituisce Base64. Una chiave i cui byte non formano UTF-8 valido non gli si può proprio passare.

Python: gmssl CryptSM4

PKCS#7 · chiave troncata a 16 byte

Scegli la modalità chiamando crypt_ecb o crypt_cbc. set_key legge solo i primi 16 byte, quindi una chiave più lunga viene troncata in silenzio, e una chiave sbagliata di solito restituisce byte vuoti invece di un errore.

Go: tjfoc/gmsm sm4

IV a zero come predefinito

Sm4Cbc usa un IV a livello di package che resta tutto a zero finché non si chiama SetIV, applica il padding PKCS#7 anche in CFB e OFB e scarta gli errori di rimozione del padding: una chiave sbagliata restituisce nil senza alcun errore.

Esempi di cifratura e decifratura SM4

Vettore di test GB/T 32907 (ECB, nessun padding)

Chiave 0123456789abcdeffedcba9876543210, testo in chiaro (hex) 0123456789abcdeffedcba9876543210
681edf34d206965e86b3e94f536e4246

È l'esempio 1 dell'Appendice A di GB/T 32907-2016: chiave e testo in chiaro sono lo stesso valore a 128 bit, e una cifratura dà 681edf34d206965e86b3e94f536e4246. Cifrando di nuovo quel risultato, per un milione di volte in totale, si ottiene 595298c7c6fd271f0402f804c33d3f66. Entrambi i valori compaiono nella tabella dei vettori di test di questa pagina, calcolati dallo stesso motore che stai usando. Il pulsante Vettore di test GB/T 32907 carica il primo.

CBC con PKCS#7: testo in ingresso, Base64 in uscita

Chiave 0123456789abcdeffedcba9876543210, IV fedcba98765432100123456789abcdef, testo in chiaro: SM4 interop test: order 20260911-0042
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y

Il testo in chiaro occupa 37 byte in UTF-8. PKCS#7 lo porta a 48 byte, cioè tre blocchi da 16 byte, che in Base64 diventano 64 caratteri. Il pulsante Carica esempio inserisce esattamente questi valori, e il pannello OpenSSL mostra un comando che riproduce la stessa stringa Base64 in un terminale.

IV sbagliato in CBC: si rompono solo i primi 16 byte

Il testo cifrato qui sopra, decifrato con IV 00000000000000000000000000000000
16 byte illeggibili, poi ": order 20260911-0042"

CBC mescola l'IV solo nel primo blocco, mentre il padding PKCS#7 si trova nell'ultimo: il controllo del padding passa comunque e OpenSSL non segnala alcun errore. Questa pagina si accorge che il primo blocco è illeggibile e ti dice che chiave e modalità sono giuste e il problema è l'IV, oppure che i primi 16 byte del testo cifrato sono essi stessi l'IV.

Come usare lo strumento di cifratura e decifratura SM4

  1. 1

    Scegli il preset di una libreria, oppure modalità e padding

    Se conosci la libreria dall'altra parte, selezionala in Usa i valori predefiniti di. Altrimenti scegli Cifra o Decifra e imposta la stessa modalità e lo stesso padding. Le modalità a flusso (CTR, CFB, OFB) non hanno padding, quindi per loro il selettore del padding è disattivato.

  2. 2

    Inserisci chiave e IV

    Entrambi sono di esattamente 16 byte. Scegli il formato in cui è scritta la stringa (hex, testo o Base64) e controlla che il contatore di byte diventi verde. I pulsanti Casuale generano valori nuovi.

  3. 3

    Incolla l'input

    Per cifrare, digita del testo (UTF-8 o GBK) o incolla dei byte in hex. Per decifrare, incolla il testo cifrato e indica se è Base64 o hex. Il risultato si aggiorna mentre scrivi.

  4. 4

    Copia il risultato o verifica l'andata e ritorno

    Copia l'output, oppure fai clic su Decifra questo testo cifrato per portarlo nella scheda di decifratura con la stessa chiave e lo stesso IV. Il pannello OpenSSL mostra un comando che riproduce il risultato.

  5. 5

    Se la decifratura fallisce, leggi la diagnosi

    La diagnosi elenca le impostazioni con cui i tuoi input si decifrano in testo leggibile. Applicane una con un clic, oppure leggi la nota se falliscono solo i primi 16 byte: indica che il problema è l'IV.

Perché la decifratura SM4 fallisce

Leggere una chiave hex come testo

Una stringa hex di 32 caratteri vale 16 byte solo se viene decodificata come hex. Letta come testo vale 32 byte, che SM4 rifiuta, oppure, nel codice che tronca o completa le chiavi in silenzio, diventa una chiave del tutto diversa.

✗ Errato 
Chiave (testo): 0123456789abcdeffedcba9876543210  -> 32 byte, rifiutata
✓ Corretto 
Chiave (hex):   0123456789abcdeffedcba9876543210  -> 16 byte

Decifrare come ECB un testo cifrato CBC

Le due parti devono usare la stessa modalità. Un testo cifrato CBC decifrato come ECB dà caratteri illeggibili in ogni blocco e di solito fallisce il controllo del padding alla fine.

✗ Errato 
cifra:   SM4/CBC/PKCS5Padding
decifra: SM4/ECB/PKCS5Padding  -> bad decrypt
✓ Corretto 
cifra:   SM4/CBC/PKCS5Padding
decifra: SM4/CBC/PKCS5Padding, stesso IV

Usare un IV diverso

In CBC un IV sbagliato non genera errori: i primi 16 byte escono illeggibili e il resto si decifra normalmente. Se è rovinato solo l'inizio del testo in chiaro, confronta gli IV.

✗ Errato 
IV di decifratura 00000000000000000000000000000000
-> 16 byte illeggibili + ": order 20260911-0042"
✓ Corretto 
IV di decifratura fedcba98765432100123456789abcdef
-> "SM4 interop test: order 20260911-0042"

Trattare come hex un testo cifrato Base64

Base64 e hex sono due modi di scrivere gli stessi byte. Leggere l'uno al posto dell'altro dà al cifrario l'input sbagliato fin dall'inizio.

✗ Errato 
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y  letto come hex -> non valido
✓ Corretto 
Wi6BuLpov8RndEfedUyLXFvDRnLMoo7T6O04Q83IzKDuDvPQ2S5clq+cEQXMvy/y  letto come Base64 -> 48 byte

Lo zero padding cancella zeri finali che fanno parte dei dati

Lo zero padding non distingue il padding dai dati, quindi un testo in chiaro che termina davvero con 0x00 perde quei byte. Usa PKCS#7 per tutto ciò che non è testo semplice.

✗ Errato 
zero padding: 61 62 00  -> si decifra in 61 62
✓ Corretto 
PKCS#7:       61 62 00  -> si decifra in 61 62 00

Dare per scontato che "SM4" indichi ovunque la stessa modalità

OpenSSL tratta sm4 come CBC. BouncyCastle, e quindi SmUtil.sm4(key) di Hutool, tratta SM4 come ECB con PKCS#7. Due sistemi che "usano semplicemente SM4" possono non concordare sulla modalità.

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

Cifrare byte GBK da una parte e UTF-8 dall'altra

getBytes() di Java senza charset usa il valore predefinito della piattaforma, che è GBK su un JDK 17 o precedente con Windows in cinese. Lo stesso testo cinese produce allora un testo cifrato diverso, e l'altra parte lo decifra in mojibake.

✗ Errato 
"国密SM4 test".getBytes()  // GBK su JDK <= 17 con Windows in cinese
-> testo cifrato ECB 3188d06cf28db70092f8753cbd5ee518
✓ Corretto 
"国密SM4 test".getBytes(StandardCharsets.UTF_8)
-> testo cifrato ECB d830308b0ae4fa7b9a2b5d59f7f65ca5

Quando serve la cifratura SM4 online

Allinea l'output SM4 tra backend e frontend
Il tuo servizio Java e il tuo client web producono testi cifrati diversi a partire dallo stesso testo. Riproduci qui ciascun lato con il preset della sua libreria e scopri quale parametro è diverso.
Fai debug di una decifratura fallita con un sistema partner
Un partner ti invia un testo cifrato SM4 che non si decifra. Incollalo con la chiave e l'IV concordati e lascia che la diagnosi trovi la modalità, il padding o la codifica che ha usato davvero.
Verifica un'implementazione di SM4
Prova il tuo codice con i vettori GB/T 32907 di questa pagina, poi confronta un'andata e ritorno in CBC, prima che l'implementazione si avvicini ai dati di produzione.
Prepara dati di test per una migrazione a SM4
Quando un sistema passa da AES a SM4, genera qui terne note di chiave, IV e testo cifrato da usare come fixture nei nuovi test.
Osserva come si comportano le modalità dei cifrari a blocchi
Cifra due blocchi identici in ECB e in CBC, oppure decifra con un IV sbagliato, e osserva cosa cambia nel testo cifrato e nell'output.

Come funzionano SM4 e le sue modalità

Dimensione del blocco, lunghezza della chiave e round
SM4 cifra blocchi da 128 bit con una chiave a 128 bit in 32 round. Ogni round applica una S-box a 8 bit a una parola da 32 bit e poi una trasformazione lineare che fa lo XOR della parola con quattro sue rotazioni. La decifratura esegue gli stessi 32 round con le chiavi di round in ordine inverso.
ECB: ogni blocco per conto suo
ECB cifra ogni blocco da 16 byte in modo indipendente. Non richiede un IV, ma blocchi uguali di testo in chiaro diventano blocchi cifrati uguali, quindi gli schemi presenti nei dati restano visibili. Richiede padding, a meno che l'input non sia un multiplo di 16 byte.
CBC: blocchi concatenati e un IV
CBC fa lo XOR di ogni blocco di testo in chiaro con il blocco cifrato precedente prima di cifrarlo, e usa l'IV per il primo blocco. Poiché l'IV entra solo nel primo blocco, un IV sbagliato corrompe esattamente i primi 16 byte del testo in chiaro e lascia intatto il padding nell'ultimo blocco, quindi spesso non compare alcun errore.
CTR, CFB e OFB: SM4 come cifrario a flusso
Queste modalità cifrano un contatore o un valore di feedback e fanno lo XOR del risultato con i dati, quindi il testo cifrato è lungo quanto il testo in chiaro e non c'è padding. In CTR l'intero IV da 16 byte viene incrementato come un unico contatore big-endian a 128 bit, come fa OpenSSL. Un IV sbagliato rende illeggibile l'intero messaggio in CTR e OFB, ma solo il primo blocco in CFB.
Regole del padding
PKCS#7 aggiunge da 1 a 16 byte di valore n, quindi anche un messaggio che è già un numero intero di blocchi riceve un blocco intero di padding. Lo zero padding aggiunge byte 0x00 solo quando servono e in decifratura rimuove tutti gli zeri finali. Senza padding i dati restano come sono e un input che non riempie blocchi interi viene rifiutato.

Best practice per la cifratura SM4

Non scegliere ECB nei nuovi progetti
ECB rivela quali blocchi sono uguali. Usa CBC o CTR, a meno che tu non debba allinearti a un sistema esistente che usa già ECB.
Usa un IV casuale nuovo per ogni messaggio
L'IV non è segreto, ma non deve ripetersi con la stessa chiave. Generalo in modo casuale per ogni messaggio e salvalo o invialo accanto al testo cifrato.
Autentica il testo cifrato
GB/T 17964-2021, lo standard cinese sulle modalità dei cifrari a blocchi, afferma che le modalità che descrive proteggono la riservatezza, non l'integrità. In CBC, cambiare un byte dell'IV trasforma pay=100.00 in pay=900.00 e la decifratura riesce comunque. Calcola un MAC su IV e testo cifrato e verificalo prima di decifrare, per esempio con il generatore HMAC.
Scrivi ogni parametro nella specifica dell'interfaccia
"Cifrato con SM4" non è una specifica. Metti per iscritto la modalità, il padding, come sono codificati chiave e IV, il set di caratteri del testo in chiaro e se il testo cifrato è in hex o in Base64.
Tieni le chiavi reali fuori dalle pagine web e dal codice sorgente
Usa questa pagina con chiavi di test. Le chiavi di produzione vanno in un sistema di gestione delle chiavi o in un modulo di sicurezza hardware, e vanno caricate a runtime, non incollate né committate nel repository.

Domande frequenti sulla cifratura SM4

Perché la decifratura SM4 fallisce con un errore di padding o con testo illeggibile?
La decifratura funziona solo se tutto coincide con il lato che ha cifrato: i byte della chiave, la modalità, l'IV, il padding e il modo in cui è stato scritto il testo cifrato (hex o Base64). L'errore che ricevi ("bad decrypt", un'eccezione di padding o una schermata di caratteri senza senso) non dice quale parametro non torna, e alcune librerie restituiscono un output vuoto invece di un errore. Incolla comunque qui testo cifrato, chiave e IV. Quando la decifratura fallisce, la pagina riprova ogni combinazione di codifica del testo cifrato, formato della chiave, modalità, IV e padding, comprese le chiavi che una libreria ha troncato in silenzio a 16 byte e il testo in chiaro codificato in GBK, ed elenca le letture che producono testo leggibile, segnalando quelle in cui il padding PKCS#7 risulta valido. Se sono sbagliati solo i primi 16 byte, chiave e modalità sono giuste e l'IV no.
Quanto è lunga una chiave SM4, e può essere a 256 bit?
Una chiave SM4 è di esattamente 128 bit, cioè 16 byte: la stessa dimensione del blocco. GB/T 32907 definisce solo questa lunghezza di chiave; non esiste SM4 a 192 o 256 bit. Se qualcuno ti chiede una chiave SM4 a 256 bit, verifica se una stringa hex di 32 cifre è stata contata come 32 caratteri da 8 bit ciascuno. Sedici byte si possono scrivere come 32 cifre hex o come 16 caratteri ASCII, e confondere le due forme è l'errore più comune sulla chiave: 0123456789abcdeffedcba9876543210 letta come hex vale 16 byte, ma la stessa stringa letta come testo vale 32 byte e viene rifiutata. Il selettore di formato e il contatore di byte accanto al campo della chiave servono proprio a intercettare questo errore.
Cos'è l'IV di SM4, e quanto deve essere lungo?
L'IV (vettore di inizializzazione) è un valore di 16 byte che entra nel primo blocco in CBC, CTR, CFB e OFB; ECB non lo usa. Deve essere di esattamente 16 byte, cioè 32 cifre hex o 16 caratteri ASCII: se ricevi un errore sulla lunghezza dell'IV, verifica se una stringa hex di 32 cifre è stata letta come 32 byte di testo. L'IV non è segreto, ma non deve ripetersi con la stessa chiave: generalo in modo casuale e invialo insieme al testo cifrato, spesso davanti. Un IV sbagliato in CBC di solito non genera errori e rende illeggibili solo i primi 16 byte. Alcune librerie usano in silenzio un IV tutto a zero quando non ne ricevono uno (sm-crypto-v2, tjfoc/gmsm per Go), mentre BouncyCastle in Java ne genera uno casuale: se quell'IV non viene salvato con il testo cifrato, nessuno potrà più decifrarlo.
Qual è la differenza tra SM4 ECB e CBC, e quale devo usare?
Usa CBC (o CTR) con un IV casuale nuovo per ogni messaggio. ECB cifra blocchi uguali da 16 byte in blocchi cifrati uguali, quindi la struttura ripetuta dei dati resta visibile nel testo cifrato. Scegli ECB solo per dialogare con un sistema che lo usa già. Nota che nessuna delle due modalità rileva le manomissioni: se ti interessa, invia anche un MAC calcolato su IV e testo cifrato, per esempio con il generatore HMAC.
Quale padding SM4 devo usare: PKCS5Padding, PKCS#7, zero padding o nessun padding?
PKCS#7 aggiunge sempre da 1 a 16 byte, ciascuno contenente il numero di byte aggiunti, così chi riceve può rimuoverlo senza ambiguità. Per un cifrario a blocchi da 16 byte come SM4, il PKCS5Padding di Java è lo stesso padding: BouncyCastle fa passare entrambi i nomi per lo stesso codice. Lo zero padding aggiunge 0x00 solo fino al confine del blocco successivo. In decifratura Hutool e BouncyCastle rimuovono tutti gli 0x00 finali, compresi i byte a zero che facevano davvero parte dei dati, mentre gmssl per Python ne rimuove solo uno. Senza padding l'input deve essere un numero intero di blocchi da 16 byte. CTR, CFB e OFB sono modalità a flusso e non usano mai padding. Se il testo decifrato termina con spazi, quadratini o a capo di troppo, il padding non è stato rimosso: dati PKCS#7 decifrati senza padding conservano alla fine n byte di valore n (0x09, 0x0A e 0x0D compaiono come tabulazioni e a capo); passa l'output a Hex e guarda l'ultimo blocco.
Quanto è lungo il testo cifrato SM4, e posso capirne la modalità?
Ragiona in byte. Con PKCS#7 in ECB o CBC il testo in chiaro viene arrotondato al multiplo di 16 successivo, e un messaggio che è già un multiplo di 16 riceve un blocco intero in più: 5 o 15 byte diventano 16, e 16 byte diventano 32. Lo zero padding riempie solo fino al multiplo di 16 successivo, senza padding la lunghezza non cambia, e in CTR, CFB e OFB il testo cifrato è lungo esattamente quanto il testo in chiaro. L'hex raddoppia il numero di byte; Base64 usa 4 × ⌈byte / 3⌉ caratteri, quindi 16 byte diventano 24 caratteri, 32 ne diventano 44 e 64 ne diventano 88. Aggiungi 16 byte se l'IV viaggia davanti. Il testo cifrato da solo non rivela la modalità, ma due indizi aiutano: una lunghezza che non è multipla di 16 esclude quasi del tutto ECB o CBC con padding, e due blocchi identici da 16 byte fanno pensare a ECB. Nel dubbio, incollalo nella scheda di decifratura e la diagnosi automatica prova le modalità al posto tuo.
SM4 dà sempre lo stesso testo cifrato, e perché quello di un altro strumento è diverso?
ECB, o qualsiasi modalità con un IV fisso, dà sempre lo stesso testo cifrato a parità di chiave e testo in chiaro; con un IV casuale nuovo a ogni esecuzione l'output cambia ogni volta, come deve essere. Oltre a questo, confronta la modalità, il padding, se la chiave è stata letta come hex o come testo, come è stato codificato il testo in chiaro (UTF-8 nella maggior parte del codice, ma GBK quando vecchio codice Java chiama getBytes() su un sistema Windows in cinese) e come viene stampato il risultato: Base64, hex minuscolo o hex maiuscolo. Con impostazioni identiche e un IV fisso, due implementazioni corrette producono lo stesso output. Se sospetti di uno dei due strumenti, verifica prima entrambi con il vettore di test GB/T 32907.
Come verifico che la mia implementazione di SM4 sia corretta?
Parti dai due vettori dell'Appendice A di GB/T 32907-2016. Con chiave e testo in chiaro entrambi uguali a 0123456789abcdeffedcba9876543210, una cifratura deve dare 681edf34d206965e86b3e94f536e4246 e un milione di cifrature concatenate 595298c7c6fd271f0402f804c33d3f66. Questi vettori verificano solo il cifrario a blocchi, quindi come passo successivo cifra un testo in CBC con chiave e IV fissi e confronta il risultato con questa pagina o con il comando OpenSSL che mostra. Il motore di questa pagina è testato su entrambi i vettori e confrontato con OpenSSL 3 in tutte e cinque le modalità.
OpenSSL può cifrare e decifrare SM4?
Sì. OpenSSL 3 include SM4 in ECB, CBC, CFB, OFB e CTR. Usa openssl enc -sm4-cbc -K <32 hex digits> -iv <32 hex digits>: -K accetta la chiave grezza in hex, quindi non c'è di mezzo nessuna password, -nopad disattiva PKCS#7 e -base64 -A legge o scrive Base64 su una sola riga. Fai attenzione a due cose: -sm4 da solo significa CBC, e un valore di -K della lunghezza sbagliata viene troncato o completato con zeri, con un semplice avviso. Il pannello OpenSSL di questa pagina costruisce il comando dalle impostazioni correnti; openssl enc non ha lo zero padding, quindi in quel caso il pannello lo segnala invece di stampare un comando che darebbe un risultato diverso.
Come decifro un testo cifrato SM4 prodotto da Java (Hutool) o da JavaScript (sm-crypto)?
Prima scopri quali modalità e padding usa davvero l'altra parte: spesso il codice non lo dice. SmUtil.sm4(key) di Hutool passa solo il nome SM4, e BouncyCastle lo completa con ECB con PKCS#7 (il PKCS5Padding di Java); solo una stringa completa come SM4/CBC/PKCS5Padding significa CBC. In JavaScript anche sm-crypto usa ECB come predefinito, vuole la chiave come stringa hex di 32 cifre e stampa hex minuscolo, mentre gm-crypt usa CBC come predefinito, vuole una chiave testuale di 16 caratteri e stampa Base64. Poi controlla il set di caratteri del testo in chiaro: i metodi stringa di Hutool usano sempre UTF-8, ma un getBytes() senza argomenti su JDK 17 o precedenti con Windows in cinese può significare GBK, e questo cambia il testo cifrato. Scegli la libreria in Usa i valori predefiniti di per impostare tutto con un clic, oppure inserisci i valori a mano; se uno di questi è incerto, incolla comunque il testo cifrato e la diagnosi automatica prova le combinazioni di modalità, padding, IV e codifica.
SM4 è sicuro, e i miei dati vengono caricati?
Come algoritmo, SM4 usa una chiave a 128 bit e 32 round; la RFC 8998 (2021) afferma che al momento della stesura non erano note chiavi deboli né problemi di sicurezza per SM4. I rischi pratici derivano da come viene usato: ECB lascia trapelare schemi ripetuti e CBC non rileva le manomissioni. Quanto a questa pagina, nulla viene caricato. I browser non includono SM4, quindi questa pagina porta con sé una propria implementazione di SM4 e la esegue in locale: puoi aprire il pannello Rete e vedere che non parte nessuna richiesta, oppure disconnetterti e continuare a usare lo strumento. Per questo va bene per dati di test, debug e studio. Non per questo, però, una pagina web diventa il posto giusto per le chiavi di produzione: quelle vanno in un sistema di gestione delle chiavi o in un modulo hardware, non nella casella di testo di un sito web, qualunque esso sia.
Qual è la differenza tra SM4 e AES?
Entrambi sono cifrari a blocchi con blocchi da 128 bit, e modalità e padding funzionano allo stesso modo per tutti e due: ecco perché i bug di interoperabilità di SM4 sono identici a quelli di AES. SM4 esegue 32 round e ha un'unica dimensione di chiave, 128 bit; AES-128 esegue 10 round, e AES ha anche chiavi a 192 e 256 bit. SM4 è lo standard nazionale cinese GB/T 32907-2016 e, dal 2021, fa parte dello standard internazionale ISO/IEC 18033-3 accanto ad AES; si usa dove è richiesta la crittografia commerciale cinese. AES è lo standard NIST FIPS 197. Per AES, usa lo strumento di cifratura AES.

Strumenti correlati

Vedi tutti gli strumenti →

Strumento di Decifratura AES — OpenSSL e CryptoJS

Strumenti di sicurezza

Decifra AES online — GCM/CBC/CTR, passphrase o chiave grezza, rileva "U2FsdGVkX1" (OpenSSL/CryptoJS). 100% nel browser, le chiavi restano sul dispositivo.

Strumento di Crittografia AES — GCM, CBC e CTR

Strumenti di sicurezza

Crittografia AES online gratuita — AES-128/192/256, GCM/CBC/CTR, passphrase (PBKDF2) o chiave grezza. Funziona al 100% nel browser; nulla viene caricato.

Generatore e verificatore di hash Bcrypt

Strumenti di sicurezza

Genera e verifica hash bcrypt delle password online: costo regolabile, prefissi $2b$/$2a$/$2y$. 100% nel tuo browser; la password non viene mai caricata.

Calcolatore di Checksum CRC

Strumenti di sicurezza

Incolla esadecimale o testo e ottieni tutte le 63 varianti CRC-8, CRC-16 e CRC-32 in una volta. Hai un checksum che non torna? Inseriscilo e lo strumento nomina la variante: MODBUS, CCITT-FALSE, XMODEM, KERMIT. Tutto in locale.

Generatore HMAC e Verificatore di Firma

Strumenti di sicurezza

Generatore e verificatore HMAC online e gratuito. Calcola HMAC-SHA256/SHA1/SHA384/SHA512 con chiavi in Testo, Hex o Base64 e output Hex/Base64/Base64URL. 100% nel tuo browser — le chiavi non lasciano mai la pagina.

Decodificatore JWT

Strumenti di sicurezza

Decodifica token JWT online con il nostro decodificatore JWT gratis. Ispeziona intestazione, payload, firma, scadenza e attestazioni. 100% browser — token mai fuori dal dispositivo. Nessuna registrazione, nessun tracciamento.