Cifratura/decifratura DES/3DES (2/3 chiavi) con ECB/CBC e PKCS#7 nel browser. Lunghezze chiavi (8/16/24 byte) validate rigorosamente, mai troncate in silenzio. Ogni risultato con il comando OpenSSL equivalente.
ECB cifra blocchi uguali in ciphertext uguali e fa trapelare i pattern — usalo solo per parlare con un sistema che lo richiede.
—
Il comando contiene la chiave che hai inserito.
| Chiave (DES singolo) | 0123456789abcdef |
|---|---|
| Plaintext | 4e6f772069732074 |
| Ciphertext (ECB, senza padding) | 3fa40e8a984d4815 |
Scritto e revisionato dagli sviluppatori che costruiscono gli strumenti di crittografia. Ogni ciphertext e ogni numero di byte in questa pagina è calcolato dal motore dello strumento e verificato da test.
8 / 16 / 24 byte DES singolo: 8 byte (56 bit effettivi). 3DES: 16 byte (2-key) o 24 byte (3-key). Materiale di chiave nominale 112/168 bit; forza di sicurezza effettiva NIST circa 80/112 bit (SP 800-57). Questo strumento rileva automaticamente dal numero di byte; le altre lunghezze generano un errore.
3fa40e8a984d4815 Chiave 0123456789abcdef, plaintext "Now is t" (hex 4e6f772069732074): DES singolo ECB senza padding produce 3fa40e8a984d4815.
8 byte 8 byte (16 cifre hex), solo CBC — ECB non lo usa. Distinto dall'IV a 16 byte di AES.
= PKCS#7 Per DES è PKCS#7 — lo stesso algoritmo di padding sotto il suo nome storico (il PKCS#5 definiva solo blocchi a 8 byte, che sono proprio quelli di DES).
Solo interop legacy No. DES singolo ritirato nel 2005; 3DES deprecato in SP 800-131A Rev.2 (2023). Solo interop legacy — per tutto il resto AES-256.
DES (Data Encryption Standard) è il cifrario a blocchi simmetrico adottato dagli enti di standardizzazione statunitensi nel 1977, basato sul design Lucifer di IBM . Processa blocchi a 64 bit (8 byte) con una chiave nominale a 64 bit di cui 56 effettivi, attraverso 16 round di una struttura Feistel.
3DES (TDEA, Triple DES) concatena DES tre volte per compensare la chiave corta: C = E_K3(D_K2(E_K1(P))). Il passaggio centrale è una decifratura, così che K1=K2=K3 collassi la catena in DES singolo — una scelta deliberata di compatibilità. La forma 2-key (K3=K1) ha circa 112 bit effettivi ed è la forma più comune nei sistemi bancari legacy.
Il NIST ha ritirato DES singolo nel 2005 (nota FIPS 46-3) e ha deprecato 3DES in SP 800-131A Rev.2 (2023). L'unico motivo per cui esistono ancora è l'interop legacy: le clearing bancarie, i gateway di pagamento e i sistemi Java/.NET/PHP degli anni '90/2000 girano ancora su crittografia dell'era DES. I nuovi progetti dovrebbero usare AES-256.
# OpenSSL single DES (legacy provider) openssl enc -des-ecb -provider legacy -provider default -K 0123456789abcdef -nopad # 3-key 3DES CBC + PKCS#7 (default provider) openssl enc -des-ede3-cbc -K <48 hex digits> -iv <16 hex digits> -base64 -A
8/16/24 byte vengono rilevati automaticamente come DES singolo / 2-key / 3-key 3DES; qualsiasi altra cosa genera un errore. A differenza del troncamento silenzioso di CryptoJS o del tronca-e-avvisa di openssl enc -K, le chiavi sbagliate falliscono ad alta voce — la prima causa di disallineamenti di interop.
La tabella del vettore di test in fondo alla pagina è derivata dallo stesso motore in fase di build, quindi i crawler leggono il valore di riferimento senza eseguire JS e il numero stampato non può mai divergere da quello interattivo.
Ogni combinazione di parametri corrisponde a un comando openssl enc che riproduce il risultato su OpenSSL 3, compresi i flag del legacy provider per DES singolo. Inviarlo all'altra parte fissa la divergenza dei parametri.
Il getBytes() di Java dell'era DES su un JDK Windows cinese produce GBK. Qui entrambe le direzioni accettano GBK, quindi il testo in cinese dei vecchi sistemi non richiede pre-conversione.
TypeScript puro, zero dipendenze, zero richieste di rete. Chiavi e testo in chiaro non lasciano mai il dispositivo; funziona offline una volta caricato. L'unica forma accettabile per uno strumento che gestisce chiavi.
"DES" usa ECB + PKCS5Padding di default Cipher.getInstance("DES") equivale a DES/ECB/PKCS5Padding; "DESede" è 3DES ma accetta solo chiavi a 24 byte — espandi K1‖K2 a K1‖K2‖K1 per la 2-key. PKCS5Padding è PKCS#7 per DES. Omettendo l'IV: la cifratura ne sceglie uno casuale (recuperabile via getIV()), la decifratura lancia "Parameters missing".
des-ede3-cbc / des-ede-cbc I nomi degli algoritmi seguono OpenSSL: des-ede3 è ECB triplo, des-ede3-cbc è CBC. $options=0 (default) produce testo Base64; OPENSSL_RAW_DATA per i byte grezzi. Le chiavi corte sono riempite di zeri in silenzio; un IV vuoto avvisa e poi cifra con un IV a zero.
-des-ede3-cbc funziona di default DES singolo richiede -provider legacy -provider default (alcune build omettono legacy del tutto). -K/-iv prendono hex; PKCS#7 di default, -nopad per disattivarlo. -K tronca le chiavi troppo lunghe con un avviso.
Una chiave grezza a 8 byte (WordArray) funziona; le lunghezze sbagliate sono riempite di zeri o troncate in silenzio (4 byte riempiti, 10 troncati — nessun errore). Una stringa come "chiave" esegue la derivazione della chiave (MD5 + salt casuale, output con prefisso Salted__, diverso ogni volta). CBC senza IV è un crash TypeError, non un IV a zero. TripleDES con chiave a 8 byte diventa silenziosamente DES singolo.
TripleDES usa CBC + PKCS7 di default TripleDESCryptoServiceProvider: Mode=CBC, Padding=PKCS7, Key di 16 o 24 byte (DES ne prende 8). .NET rifiuta le chiavi deboli (la parità viene normalizzata prima, poi confrontata con la tabella delle chiavi deboli — una chiave nulla lancia un'eccezione) mentre ogni altra libreria le accetta. Occhio quando migrisci.
des.NewCipher fornisce l'interfaccia a blocchi grezza con chiave a 8 byte; la avvolgi tu in cipher.NewCBCEncrypter e simili. Il 3DES è des.NewTripleDESCipher (24 byte). La lunghezza dell'IV è verificata più rigorosamente che nella maggior parte dei linguaggi.
Chiave 0123456789abcdef, testo in chiaro (hex) 4e6f772069732074
3fa40e8a984d4815
Il testo in chiaro è la stringa ASCII "Now is t". È il classico vettore FIPS 81, e la tabella in fondo alla pagina è calcolata in fase di build dallo stesso motore — se la tua implementazione DES non produce questo valore con questi input, ha un bug.
Chiave 0123456789abcdeffedcba9876543210 (16 byte), IV fedcba9876543210, testo in chiaro: DES interop test: order 20260927-0042
QmnMoewSecp7Z7cr/w3/4AjM9lpFo1swc4dfLNH5UkgCwU5n7WIdKA==
Una chiave a 16 byte è trattata come 3DES 2-key (K1 = primi 8 byte, K2 = ultimi 8, K3 = K1 — l'assemblaggio EDE2). PKCS#7 su un blocco a 8 byte è esattamente ciò che Java chiama "PKCS5Padding" per DES: stesso schema, cambia solo la dimensione del blocco.
Chiave 0123456789abcdef23456789abcdef010456789abcdef012 (24 byte), IV fedcba9876543210, testo in chiaro: hello des
DhDQX9sfxKOirZ8eyqT7Jg==
Una chiave a 24 byte è il tre-chiavi completo EDE3: C = E_K3(D_K2(E_K1(P))). Delle tre lunghezze di chiave è l'unica forma senza equivalente degenerato — sia la 2-key che K1=K2=K3 collassano in cifrari più deboli.
Per il DES/ECB/PKCS5Padding di Java scegli ECB + PKCS#7; per openssl enc -des-ede3-cbc scegli CBC + PKCS#7. Il vecchio codice PHP mcrypt usa tipicamente Zero padding.
Il numero di byte seleziona il cifrario: 8 = DES singolo, 16 = 3DES 2-key, 24 = 3DES 3-key. Scegli Hex, Text o Base64; il badge mostra il numero reale di byte e la forma rilevata. Lunghezze sbagliate generano un errore — niente viene mai troncato.
ECB non richiede IV. L'IV deve essere esattamente 8 byte — 16 cifre esadecimali, non le 32 di AES. Il pulsante Random ne genera uno fresco.
Cifratura: inserisci testo (UTF-8/GBK) o hex. Decifratura: incolla ciphertext Base64 o hex. I risultati si aggiornano mentre scrivi, con copia con un clic e verifica di round-trip tramite il pulsante Decrypt-this.
Il pannello richiudibile fornisce un comando openssl enc che riproduce il risultato corrente (chiave inclusa; i comandi DES singolo portano -provider legacy -provider default). Inviarlo a chi stai interoperando è il modo più rapido per stabilire di chi è il parametro sbagliato.
Una "chiave DES" di 32 caratteri hex è 16 byte — è 3DES 2-key, non DES singolo. Al contrario, fornire una chiave a 24 byte a un sistema solo-2-key fallisce anch'esso.
Chiave 0123456789abcdeffedcba9876543210 (16 byte) con DES singolo selezionato → errore "la chiave deve essere esattamente 8 byte"
La stessa chiave come 16 byte (3DES 2-key) → decifra pulitamente
Java scrive "PKCS5Padding" per DES ma esegue l'algoritmo PKCS#7 (il PKCS#5 ha definito solo il padding per blocchi a 8 byte, che coincide col blocco di DES, quindi il nome è rimasto). Selezionare None o Zero su un ciphertext JCE fallisce sempre.
Ciphertext JCE `DES/ECB/PKCS5Padding` decifrato come "nessun padding" → spazzatura in coda o errore di bad-padding
Selezionare PKCS#7 (Java PKCS5Padding) → output pulito
Il blocco di DES è 8 byte, quindi anche il suo IV è 8 byte. Incollare un IV a 32 cifre hex da codice AES fallisce il controllo di lunghezza; un IV a 8 cifre viene riempito con zeri e letto male.
IV 00000000000000000000000000000000 (32 cifre hex) → errore "l'IV deve essere 8 byte"
IV 0000000000000000 (16 cifre hex) → accettato
Decifrare ciphertext multi-blocco con un IV sbagliato non genera errori — solo il primo blocco a 8 byte è spazzatura, il resto si decifra bene (l'IV raggiunge solo il primo blocco, e il controllo del padding vive nell'ultimo blocco). Quando vedi "i primi caratteri sono illeggibili, il resto va bene", controlla l'IV prima della chiave; il ciphertext a blocco singolo invece rompe il padding e lancia bad decrypt.
Ciphertext multi-blocco + IV sbagliato → primi 8 byte illeggibili, resto normale — scambiato per "chiave sbagliata"
Cambiare solo l'IV (chiave intoccata) → il primo blocco si recupera, confermando che l'IV era il problema
-K tiene solo i byte che gli servono e stampa un avviso di una riga che gli script inghiottono. Quando l'altra parte dice "la chiave è queste 48 cifre hex" ma in realtà ha cifrato con le prime 16, decifrare con la chiave completa fallisce.
Shell: `-K <49 cifre hex>` → "hex string is too long, ignoring excess" perso nella pipeline
Usa il comando equivalente di questo strumento per generare un `-K` della lunghezza corretta, poi confronta i byte della chiave con l'altra parte
Il provider predefinito di OpenSSL 3 non ha des-ecb/des-cbc; eseguirlo nudo lancia digital envelope routines::unsupported. Aggiungi -provider legacy -provider default, o usa des-ede3 con K‖K‖K (algebricamente DES singolo).
openssl enc -des-ecb -K … → Error: unsupported
openssl enc -des-ecb -provider legacy -provider default -K … (o des-ede3-ecb -K <K‖K‖K>)
Cipher.getInstance("DES/ECB/PKCS5Padding") o di openssl_encrypt(..., 'des-ede3-cbc', ...) con questo strumento byte per byte prima di sostituire. Le forme 2-key/3-key sono rilevate dalla lunghezza della chiave, quindi non c'è nulla da indovinare.03 03 03) e, con il blocco già pieno, aggiunge un intero blocco extra — questo è il "PKCS5Padding" di Java per DES. Zero padding riempie con 0x00 ed è con perdita quando il plaintext termina davvero con 0x00. None richiede un multiplo esatto di 8.-provider legacy -provider default, e alcune build (incluso OpenSSL incluso in Node) lo omettono del tutto. Il 3DES (des-ede/des-ede3) resta nel provider predefinito. Il motore puro TS di questo strumento non è toccato.PKCS5Padding di Java È PKCS#7 per DES — non scegliere None). Il pannello richiudibile a destra mostra un comando OpenSSL equivalente per le impostazioni correnti; inviarlo all'altra parte è il modo più rapido per trovare la divergenza. openssl enc -K invece troncano o riempiono con zeri in silenzio, ed è la causa numero uno dei fallimenti di interop. DES/ECB/PKCS5Padding di Java in questo strumento?Cipher.getInstance("DES/ECB/PKCS5Padding") di Java si decifra qui con ECB + PKCS#7 e una chiave DES singolo a 8 byte. ⚠️ Il 3DES di Java (DESede) accetta solo chiavi a 24 byte — per la forma 2-key devi espandere K1‖K2 a K1‖K2‖K1 tu stesso. des-ede3-cbc è 3DES 3-key + CBC, des-ede3-ecb è 3-key + ECB; des-ede-cbc è la forma 2-key. Una chiave a 24 byte seleziona 3-key, 16 byte seleziona 2-key. "DES" nudo di Java usa ECB di default, i nomi di OpenSSL senza suffisso di modalità, des-ede3/des-ede, sono ECB (l'alias di CBC è -des3); openssl_encrypt di PHP richiede il nome dell'algoritmo esplicito — a confondere è che di default produce testo Base64, non byte grezzi; ③ padding — il vecchio mcrypt di PHP spesso usava Zero padding, il JCE usa PKCS#5/#7; ④ codifica — hex vs Base64, e maiuscole/minuscole; ⑤ la trappola della password di CryptoJS — passare una stringa come "chiave" fa eseguire la derivazione della chiave (MD5 + salt casuale, output con prefisso Salted__, diverso ogni volta), che non è affatto la chiave grezza — la causa principale del "stesso codice, risultato diverso a ogni esecuzione". Questo strumento ti lascia cambiare uno a uno ciascun parametro; il comando OpenSSL equivalente a destra può essere inviato all'altra parte per riprodurre. 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.
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.
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.
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.
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.
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.