DES/3DES (2/3 sleutels) met ECB/CBC en PKCS#7 versleutelen in je browser. Sleutellengtes (8/16/24 bytes) strikt gevalideerd — nooit stilletjes afgekapt. Elk resultaat met een gelijkwaardig OpenSSL-commando.
ECB versleutelt gelijke blokken naar gelijke cijfertekst en laat patronen lekken — gebruik het alleen om met een systeem te praten dat het vereist.
—
Het commando bevat de sleutel die je hebt ingevoerd.
| Sleutel (enkele DES) | 0123456789abcdef |
|---|---|
| Platte tekst | 4e6f772069732074 |
| Cijfertekst (ECB, geen padding) | 3fa40e8a984d4815 |
Geschreven en gereviewd door de ontwikkelaars die de crypto-tools bouwen. Elke cijfertekst en elk aantal bytes op deze pagina wordt door de engine van de tool berekend en door tests gecontroleerd.
8 / 16 / 24 bytes Enkele DES: 8 bytes (56 effectieve bits). 3DES: 16 bytes (2-key) of 24 bytes (3-key). Nominaal sleutelmateriaal 112/168 bits; effectieve veiligheidssterkte NIST circa 80/112 bits (SP 800-57). Deze tool detecteert automatisch op het aantal bytes; andere lengtes geven een fout.
3fa40e8a984d4815 Sleutel 0123456789abcdef, platte tekst "Now is t" (hex 4e6f772069732074): enkele DES ECB zonder padding geeft 3fa40e8a984d4815.
8 bytes 8 bytes (16 hex-cijfers), alleen CBC — ECB gebruikt er geen. Anders dan de 16-bytes IV van AES.
= PKCS#7 Voor DES is het PKCS#7 — hetzelfde padding-algoritme onder zijn historische naam (PKCS#5 definieerde alleen 8-bytes blokken, wat toevallig de blokken van DES zijn).
Alleen legacy-interop Nee. Enkele DES teruggetrokken in 2005; 3DES gedeprecieerd in SP 800-131A Rev.2 (2023). Alleen legacy-interop — gebruik AES-256 voor alles wat nieuw is.
DES (Data Encryption Standard) is het symmetrische blokcijfer dat de Amerikaanse standaardisatieorganisatie in 1977 aannam, gebaseerd op het Lucifer-ontwerp van IBM . Het verwerkt 64-bits (8-bytes) blokken onder een nominale 64-bits sleutel met 56 effectieve bits, via 16 rondes van een Feistel-structuur.
3DES (TDEA, Triple DES) koppelt DES drie keer aan elkaar om de korte sleutel te verhelpen: C = E_K3(D_K2(E_K1(P))). De middelste stap is een ontsleuteling, zodat K1=K2=K3 de keten laat uiteenvallen in enkele DES — een bewuste compatibiliteitskeuze. De 2-key-vorm (K3=K1) heeft circa 112 effectieve bits en is de meest voorkomende vorm in legacy-banksystemen.
NIST nam enkele DES in 2005 uit de roulatie (FIPS 46-3-mededeling) en deprecieerde 3DES in SP 800-131A Rev.2 (2023). De enige reden dat ze nog bestaan is legacy-interop: bankclearings, betalingsgateways en Java/.NET/PHP-systemen uit de jaren '90/'00 draaien nog steeds op cryptografie uit het DES-tijdperk. Nieuwe ontwerpen moeten AES-256 gebruiken.
# 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 bytes worden automatisch herkend als enkele DES / 2-key / 3-key 3DES; al het andere geeft een fout. In tegenstelling tot de stille truncatie van CryptoJS of het afkappen-met-waarschuwing van openssl enc -K, falen verkeerde sleutels luid — de nummer één oorzaak van interop-mismatches.
De testvectortabel onderaan wordt tijdens de build door dezelfde engine afgeleid, zodat crawlers de referentiewaarde lezen zonder JS uit te voeren en het afgedrukte getal nooit kan afwijken van het interactieve.
Elke parametercombinatie hoort bij een openssl enc-commando dat het resultaat op OpenSSL 3 reproduceert, inclusief de legacy-provider-flags voor enkele DES. Stuur het naar de andere kant om de parameterafwijking vast te pinnen.
DES-tijdperk Java getBytes() op een Chinese Windows JDK produceert GBK. Beide richtingen accepteren hier GBK, dus Chinese platte tekst van oude systemen hoeft niet vooraf geconverteerd.
Puur TypeScript, nul afhankelijkheden, nul netwerkverzoeken. Sleutels en platte tekst verlaten het apparaat nooit; werkt offline zodra geladen. De enige acceptabele vorm voor een tool die sleutels verwerkt.
"DES" gebruikt standaard ECB + PKCS5Padding Cipher.getInstance("DES") is gelijk aan DES/ECB/PKCS5Padding; "DESede" is 3DES maar accepteert alleen 24-bytes sleutels — breid K1‖K2 zelf uit naar K1‖K2‖K1 voor 2-key. PKCS5Padding is PKCS#7 voor DES. IV weglaten: versleutelen kiest een willekeurige (op te halen via getIV()), ontsleutelen gooit "Parameters missing".
des-ede3-cbc / des-ede-cbc De algoritmenamen volgen OpenSSL: des-ede3 is drievoudige ECB, des-ede3-cbc is CBC. $options=0 (standaard) geeft Base64-tekst; OPENSSL_RAW_DATA voor ruwe bytes. Korte sleutels worden stilletjes met nullen gevuld; een lege IV waarschuwt en versleutelt dan met een nul-IV.
-des-ede3-cbc werkt standaard Enkele DES heeft -provider legacy -provider default nodig (sommige builds laten legacy helemaal weg). -K/-iv nemen hex; PKCS#7 standaard, -nopad om uit te zetten. -K kapt te lange sleutels af met een waarschuwing.
Een 8-bytes raw-sleutel (WordArray) werkt; verkeerde lengtes worden stilletjes met nullen gevuld of afgekapt (4 bytes gevuld, 10 afgekapt — geen fout). Een string als "sleutel" laat key derivation draaien (MD5 + willekeurige salt, uitvoer met voorvoegsel Salted__, elke keer anders). CBC zonder IV is een TypeError-crash, geen nul-IV. TripleDES met een 8-bytes sleutel wordt stilletjes enkele DES.
TripleDES gebruikt standaard CBC + PKCS7 TripleDESCryptoServiceProvider: Mode=CBC, Padding=PKCS7, Key van 16 of 24 bytes (DES neemt 8). .NET weigert zwakke sleutels (de pariteit wordt eerst genormaliseerd en dan vergeleken met de tabel met zwakke sleutels — een nul-sleutel gooit een exception) terwijl elke andere bibliotheek ze accepteert. Let hierop bij migreren.
des.NewCipher geeft de ruze blok-interface met 8-bytes sleutel; je wikkelt die zelf in cipher.NewCBCEncrypter en dergelijke. 3DES is des.NewTripleDESCipher (24 bytes). De IV-lengte wordt strenger gecontroleerd dan in de meeste talen.
Sleutel 0123456789abcdef, platte tekst (hex) 4e6f772069732074
3fa40e8a984d4815
De platte tekst is de ASCII-string "Now is t". Dit is de klassieke FIPS 81-vector, en de tabel onderaan de pagina wordt bij de build berekend door dezelfde engine — als jouw DES-implementatie met deze invoer niet deze waarde oplevert, zit er een bug in.
Sleutel 0123456789abcdeffedcba9876543210 (16 bytes), IV fedcba9876543210, platte tekst: DES interop test: order 20260927-0042
QmnMoewSecp7Z7cr/w3/4AjM9lpFo1swc4dfLNH5UkgCwU5n7WIdKA==
Een sleutel van 16 bytes wordt behandeld als 2-key 3DES (K1 = eerste 8 bytes, K2 = laatste 8, K3 = K1 — de EDE2-assemblage). PKCS#7 over een blok van 8 bytes is precies wat Java "PKCS5Padding" noemt voor DES: hetzelfde schema, alleen de blokgrootte verschilt.
Sleutel 0123456789abcdef23456789abcdef010456789abcdef012 (24 bytes), IV fedcba9876543210, platte tekst: hello des
DhDQX9sfxKOirZ8eyqT7Jg==
Een sleutel van 24 bytes is de volledige drievoudige EDE3: C = E_K3(D_K2(E_K1(P))). Van de drie sleutellengtes is dit de enige vorm zonder gedegenereerd equivalent — zowel 2-key als K1=K2=K3 klappen uiteen in zwakkere cijfers.
Voor Java DES/ECB/PKCS5Padding kies je ECB + PKCS#7; voor openssl enc -des-ede3-cbc kies je CBC + PKCS#7. Oude PHP mcrypt-code gebruikt doorgaans Zero padding.
Het aantal bytes selecteert het cijfer: 8 = enkele DES, 16 = 2-key 3DES, 24 = 3-key 3DES. Kies Hex, Text of Base64; de badge toont het echte aantal bytes en de gedetecteerde vorm. Verkeerde lengtes geven een fout — er wordt nooit iets afgekapt.
ECB heeft geen IV nodig. De IV moet exact 8 bytes zijn — 16 hex-cijfers, niet de 32 van AES. De knop Random genereert een verse.
Versleutelen: voer tekst (UTF-8/GBK) of hex in. Ontsleutelen: plak Base64- of hex-cijfertekst. De resultaten worden bijgewerkt terwijl je typt, met kopiëren in één klik en een round-tripcontrole via de Decrypt-this-knop.
Het inklapbare paneel geeft een openssl enc-commando dat het huidige resultaat reproduceert (sleutel inbegrepen; enkele-DES-commando's dragen -provider legacy -provider default). Stuur het naar wie je mee interoperaat — de snelste manier om te beslissen wiens parameter fout zit.
Een "DES-sleutel" van 32 hex-tekens is 16 bytes — dat is 2-key 3DES, niet enkele DES. Omgekeerd mislukt het ook om een 24-bytes sleutel aan een alleen-2-key-systeem te geven.
Sleutel 0123456789abcdeffedcba9876543210 (16 bytes) met enkele DES geselecteerd → fout "de sleutel moet exact 8 bytes zijn"
Dezelfde sleutel als 16 bytes (2-key 3DES) → ontsleutelt netjes
Java schrijft "PKCS5Padding" voor DES maar voert het PKCS#7-algoritme uit (PKCS#5 definieerde ooit alleen 8-bytes-blokpaddings, die gelijk zijn aan het blok van DES, dus de naam bleef hangen). None of Zero kiezen tegen een JCE-cijfertekst faalt altijd.
JCE `DES/ECB/PKCS5Padding`-cijfertekst ontsleuteld als "geen padding" → rommel aan het eind of een bad-paddingfout
PKCS#7 (Java PKCS5Padding) selecteren → schone uitvoer
Het blok van DES is 8 bytes, dus de IV is ook 8 bytes. Een IV van 32 hex-cijfers uit AES-code plakken faalt op de lengtecontrole; een IV van 8 hex-cijfers wordt met nullen gevuld en verkeerd gelezen.
IV 00000000000000000000000000000000 (32 hex-cijfers) → fout "de IV moet 8 bytes zijn"
IV 0000000000000000 (16 hex-cijfers) → geaccepteerd
Multi-blokcijfertekst ontsleutelen met een verkeerde IV geeft geen fout — alleen het eerste 8-bytes blok is rommel, de rest ontsleutelt prima (de IV bereikt alleen blok één, en de paddingcontrole zit in het laatste blok). Zie je "de eerste paar tekens zijn onleesbaar, de rest is prima", controleer dan eerst de IV vóór de sleutel; één-blokcijfertekst breekt in plaats daarvan de padding en gooit bad decrypt.
Multi-blokcijfertekst + verkeerde IV → eerste 8 bytes onleesbaar, rest normaal — verkeerd gelezen als "verkeerde sleutel"
Alleen de IV veranderen (sleutel onaangetast) → het eerste blok herstelt, wat bevestigt dat de IV het probleem was
-K houdt alleen de bytes die het nodig heeft en drukt een waarschuwing van één regel af die scripts doorslikken. Als de andere kant zegt "de sleutel is deze 48 hex-cijfers" maar in werkelijkheid met de eerste 16 versleutelde, mislukt het ontsleutelen met de volledige sleutel.
Shell: `-K <49 hex-cijfers>` → "hex string is too long, ignoring excess" verloren in de pijplijn
Gebruik het gelijkwaardige commando van deze tool om een `-K` met de juiste lengte te genereren, en vergelijk daarna de sleutelbytes met de andere kant
De default provider van OpenSSL 3 heeft geen des-ecb/des-cbc; uitgevoerd zonder extra opties gooit het digital envelope routines::unsupported. Voeg -provider legacy -provider default toe, of gebruik des-ede3 met K‖K‖K (algebraïsch enkele DES).
openssl enc -des-ecb -K … → Error: unsupported
openssl enc -des-ecb -provider legacy -provider default -K … (of des-ede3-ecb -K <K‖K‖K>)
Cipher.getInstance("DES/ECB/PKCS5Padding") of openssl_encrypt(..., 'des-ede3-cbc', ...) byte voor byte met deze tool vóór de omschakeling. De 2-key/3-key-vormen worden uit de sleutellengte gedetecteerd, dus er is niets te raden.03 03 03) en vult een vol blok met een hele extra blok — dit is Java's "PKCS5Padding" voor DES. Zero vult met 0x00 en is verliesgevend als de platte tekst echt op 0x00 eindigt. None vereist een exact veelvoud van 8.-provider legacy -provider default nodig, en sommige builds (inclusief de met Node meegeleverde OpenSSL) laten die helemaal weg. 3DES (des-ede/des-ede3) blijft in de default provider. De pure TS-engine van deze tool is niet getroffen.PKCS5Padding IS PKCS#7 voor DES — kies geen None). Het inklapbare paneel rechts toont een gelijkwaardig OpenSSL-commando voor de huidige instellingen; dat naar de andere kant sturen is de snelste manier om het verschil te vinden. openssl enc -K kappen of vullen met nullen in plaats daarvan, en dat is de nummer één oorzaak van interop-fouten. DES/ECB/PKCS5Padding in deze tool overeen mee?Cipher.getInstance("DES/ECB/PKCS5Padding") wordt hier ontsleuteld met ECB + PKCS#7 en een 8-bytes enkele-DES-sleutel. ⚠️ Java's 3DES (DESede) accepteert alleen 24-bytes sleutels — voor de 2-key-vorm moet je K1‖K2 zelf uitbreiden naar K1‖K2‖K1. des-ede3-cbc is 3-key 3DES + CBC, des-ede3-ecb is 3-key + ECB; des-ede-cbc is de 2-key-vorm. Een 24-bytes sleutel selecteert 3-key, 16 bytes selecteert 2-key. "DES" gebruikt standaard ECB, OpenSSL's namen zonder modus-achtervoegsel, des-ede3/des-ede, zijn ECB (het CBC-alias is -des3); PHP's openssl_encrypt vereist een expliciete algoritmenaam — verwarrend is dat het standaard Base64-tekst uitvoert, geen ruwe bytes; ③ padding — oude PHP mcrypt gebruikte vaak Zero padding, JCE gebruikt PKCS#5/#7; ④ codering — hex vs Base64, en hoofdlettergebruik; ⑤ de CryptoJS-wachtwoordval — een string als "sleutel" doorgeven laat key derivation draaien (MD5 + willekeurige salt, uitvoer met voorvoegsel Salted__, elke keer anders), en dat is helemaal niet de ruwe sleutel — de grootste oorzaak van "dezelfde code, elke run een ander resultaat". Deze tool laat je elk van deze omdraaien; het gelijkwaardige OpenSSL-commando rechts kan naar de andere kant worden gestuurd om het te reproduceren. Beveiligingstools
Ontsleutel AES online — GCM/CBC/CTR, wachtwoordzin of ruwe sleutel, detecteert automatisch het OpenSSL- & CryptoJS-formaat "U2FsdGVkX1". 100% in de browser, sleutels verlaten de pagina nooit.
Beveiligingstools
Gratis AES-versleuteling online — AES-128/192/256, GCM/CBC/CTR, wachtwoordzin (PBKDF2) of ruwe sleutel. Draait 100% in je browser; niets wordt geüpload.
Beveiligingstools
Genereer en verifieer bcrypt-wachtwoordhashes online — instelbare kostenfactor, $2b$/$2a$/$2y$-prefixes. 100% in je browser; je wachtwoord wordt nooit geüpload.
Beveiligingstools
Plak hex of tekst en bereken in één keer alle 63 CRC-8-, CRC-16- en CRC-32-varianten. Checksum die niet klopt? Vul hem in en de tool benoemt de variant: MODBUS, CCITT-FALSE, XMODEM, KERMIT. Alles draait in je browser.
Beveiligingstools
Gratis online HMAC-generator en -verificator. Bereken HMAC-SHA256/SHA1/SHA384/SHA512 met sleutels in Tekst, Hex of Base64 en Hex/Base64/Base64URL-uitvoer. 100% in je browser — sleutels verlaten nooit de pagina.
Beveiligingstools
Decodeer JWT-tokens direct in je browser. Inspecteer header, payload, signature, vervaldatum en claims. 100% privé — je token verlaat je apparaat nooit.