复制代码代码如下::
// Paul Tero, Juli 2001
//http://www.tero.co.uk/des/
//
// optimiert für die Leistung mit großen Blöcken von Michael Hayworth, November 2001
//http://www.netdealing.com
//
// Diese Software wird "wie es ist" und bereitgestellt
// alle ausdrücklichen oder implizierten Garantien, einschließlich, aber nicht beschränkt auf die, die
// implizite Garantien für Handelsfähigkeit und Fitness für einen bestimmten Zweck
// werden abgelehnt. In keiner Veranstaltung haftet der Autor oder die Mitwirkenden
// für direkte, indirekte, zufällige, spezielle, vorbildliche oder Folge
// Schäden (einschließlich, aber nicht beschränkt auf die Beschaffung von Ersatzwaren
// oder Dienstleistungen; Nutzungsverlust, Daten oder Gewinne; Oder Geschäftsunterbrechung)
// wie verursacht und auf jegliche Haftungstheorie, ob im Vertrag, streng
// Haftung oder unerlaubte Handlung (einschließlich Fahrlässigkeit oder anderweitig), die sich in irgendeiner Weise ergeben
// Aus der Verwendung dieser Software, auch wenn sie über die Möglichkeit von beraten ist
// solcher Schaden.
// Des
// Dies nimmt den Schlüssel, die Nachricht und die Verschlüsselung oder Entschlüsselung an
Funktion DES (Schlüssel, Nachricht, Verschlüsseln, Modus, IV, Padding) {
// Das Deklarieren dieses lokalen beschleunigt die Dinge ein bisschen
var spfunction1 = new Array (0x1010400,0,0x10000,0x1010404,0x1010004,0x10404,0x4,0x10000,0x400,0x1010400,0x1010404,0x400,0x1000404,0x1010004,0x1000000,0x4,0x404,0x1000400,0x1000400,0x10400,0x10400,0x1010000, 0x1010000,0x1000404,0x10004,0x1000004,0x1000004,0x10004,0,0x404,0x10404,0x1000000,0x10000,0x1010404,0x4,0x1010000,0x1010400,0x1000000,0x1000000,0x400,0x1010004,0x10000,0x10400,0x1000004,0x400,0x4,0x1000404, 0x10404,0x1010404,0x10004,0x1010000,0x1000404,0x1000004,0x404,0 x 10404.0x10400,0x404,0x1000400,0x1000400,0x10004,0x10400,0,0 x 1010004).
var spfunction2 = new Array (-0x7fef7fe0,-0x7fff8000,0x8000,0x108020,0x100000,0x20,-0x7fefffe0,-0x7fff7fe0,-0x7fffffe0,-0x7fef7fe0,-0x7fef8000,-0x80000000,-0x7fff8000,0x100000,0x20,-0x7fefffe0,0x108000, 0x100020, -0x7ffff7fe0,0, -0x800000,0x8000,0x108020, -0x7ff00000,0x100020, -0x7ffffFFFe0,0 x 108000,0x8020, -0x7fef8000, -0x7ff00000,0x8020, 0,0 x 80202020202020202020202020,0 x 8020, 0,0x7000,0 x 8020202020202020 x 7f00000,0x8020, 0,0x7000, 0,0 x 8020202020202020202020. 0x7fff7fe0, -0x7ff00000 ,-0x7fef8000,0x8000,-0x7ff00000,-0x7fff8000,0x20,-0x7fef7fe0,0x108020,0x20,0x8000,-0x80000000,0x8020,-0x7fef8000,0x100000,-0x7fffffe0,0x100020,-0x7fff7fe0,-0x7fffffe0,0x100020,0x108000,0, -0x7fff8000,0x8020, -0x80000000, -0x7Fefffe0, -0x7FEF7FE0,0x108000);
var spfunction3 = new Array (0x208,0x8020200,0,0x8020008,0x8000200,0,0x20208,0x8000200,0x20008,0x8000008,0x8000008,0x20000,0x8020208,0x20008,0x8020000,0x208,0x8000000,0x8,0x8020200,0x200,0x20200,0x8020000, 0x8020008,0x20208,0x8000208,0x20200,0x200,0x800008,0x8.0x80208,0 x 800000000.0x8020200,0x800000000,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0x200,0 x 200,0x200,0 x 200,0x2 , 0x8020208,0x8000200,0x8000008,0x200,0,, 0x8020008,0x8000208,0x20000.0x8000000,0x80208,0x8.0x208.0x20200,0x8000008,0x8020000,0x8000208,0x208,020000,0x208,0x8,0x8,0x8, 0x808, 0x8,0x8.0x808, 0x8,0x808, 0x8, 0x8, 0x808,0x208),;
var spfunction4 = new Array (0x802001,0x2081,0x2081,0x80,0x802080,0x800081,0x800001,0x2001,0,0x802000,0x802000,0x802081,0x81,0,0x800080,0x800001,0x1,0x2000,0x800000,0x802001,0x80,0x800000, 0x2001,0x2080,0x800081,0x1,0x2080,0x800080,0x2000,0x802080,02081,0x81,0x800080,0x8001x80x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,08080808080808080,02 00081,0x1.0x802001,0x2081,0x2081, 0x80,0x802081,0x81,0x1,0x2000.0x8001,0x2001,0x802080,0x800081,0x2001,0x2080,0x800000,0x802001,0x80,0x800000,0x2000,0x000,0x802080);
var spfunction5 = new Array (0x100,0x2080100,0x2080000,0x42000100,0x80000,0x100,0x40000000,0x2080000,0x40080100,0x80000,0x2000100,0x40080100,0x42000100,0x42080000,0x80100,0x40000000,0x2000000,0x40080000,0x40080000,0,0x40000100,0x42080100, 0x42080100,0x2000100,0x42080000,0x40000100,0,0x42000000,0x2080100,0x2000000,0x42000000,0x80100,0x80000,0x42000100,0x100,0x2000000,0x40000000,0x2080000,0x42000100,0x40080100,0x2000100,0x40000000,0x42080000,0x2080100,0x40080100,0x100,0x2000000, 0x42080000,0x42080100,0x80100,0x42000000,0x42080100,0x2080000,0,0x40080000,0x42000000,0x80100,0x2000100,0x40000100,0x80000,0,0x40080000,0x2080100,0x40000100);
var spfunction6 = new Array (0x20000010,0x20400000,0x4000,0x20404010,0x20400000,0x10,0x20404010,0x400000,0x20004000,0x404010,0x400000,0x20000010,0x400010,0x20004000,0x20000000,0x4010,0,0x400010,0x20004010,0x4000,0x404000,0x20004010, 0x10,0x20400010,0x20400010,0,0x404010,0x20404000,0x4010,0x404000,0x20404000,0x20000000,0x20004000,0x10,0x20400010,0x404000,0x20404010,0x400000,0x4010,0x20000010,0x400000,0x20004000,0x20000000,0x4010,0x20000010,0x20404010,0x404000, 0x20400000,0x404010,0x20404000,0,0x20400010,0x10 x 4000,0x20400000.0x404010,0x4000,0x400010,0x20004010,0x20404000,0x200000,0x4000,0x4000, 0x400010010), 0 x 4000, 0x4000, 0x4000, 0x400010, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0x4000, 0 x 4000,01010), 0 x 4000,0 x 4000.01010010).
var spfunction7 = new Array (0x200000,0x4200002,0x4000802,0,0x800,0x4000802,0x200802,0x4200800,0x4200802,0x200000,0,0x4000002,0x2,0x4000000,0x4200002,0x802,0x4000800,0x200802,0x200002,0x4000800,0x4000002,0x4200000, 0x4200800,0x200002,0x4200000,0x800,0x802,0x4200802,0x200800,0 x 400000000,0x200800,0x4000000,0x200800,0x200000,0x2,02,02,02,02,020008000800080008000800080008000800080008000800080002,020002,020002000200020002000200020002 , 0x200002.0x4000000,0x4000800,0x200000,0x4200800,0x802.0x200802,, 0x4200800,0x802,0x4000002,0x4200802,0x4200000,0x200800,0,0x2,0x4200802,0,0x200802,0x4200000,0x800,0x4000002,0x4000800,0x800,0x200002);
var spfunction8 = new Array (0x10001040,0x1000,0x40000,0x10041040,0x10000000,0x10001040,0x40,0x10000000,0x40040,0x10040000,0x10041040,0x41000,0x10041000,0x41040,0x1000,0x40,0x10040000,0x10000040,0x10001000,0x1040,0x41000,0x40040, 0x10040040,0x10041000,0x1040,0,0,0x10040040,0x10000040,0x1000.0x41040,0x4000000,0x41040,0x4000000,0x1000,0x40 x 4040,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x10004040404040404040404040404040 , 0x40,0x10000040,0x10040000,0x10040040,0x10000000.0x40000,, 0x10001040,0,0x10041040,0x40040,0x10000040,0x10040000,0x10001000, 0x10001040,0,0x10041040,0x41000,0x41000,0 x 104040404040404040404040404040.
// Erstellen Sie die 16 oder 48 Subkeys, die wir benötigen
var keys = Des_CreateKeys (Schlüssel);
var m = 0, i, j, temp2, rechts1, rechts2, links, rechts, schleifen;
var cbcleft, cbcleft2, cbcright, cbcright2
var endloop, loopinc;
var len = message.length;
var chunk = 0;
// Richten Sie die Schleifen für Single und Triple DES ein
var iterations = keys.length == 32? 3: 9; // Single oder Triple DES
if (iterations == 3) {looping = verschlüsseln? Neuarray (0, 32, 2): Neuarray (30, -2, -2);}
sonst {Looping = Verschlüsselung? New Array (0, 32, 2, 62, 30, -2, 64, 96, 2): Neuarray (94, 62, -2, 32, 64, 2, 30, -2, -2);}
// pad die Nachricht abhängig vom Padding -Parameter
if (padding == 2) Nachricht += ""; // pad die Nachricht mit Leerzeichen
sonst if (padding == 1) {temp = 8- (len%8); Nachricht += string.fromCharCode (temp, temp, temp, temp, temp, temp, temp, temp); if (temp == 8) len+= 8;} // pkcs7 Polsterung
else if (! padding) meldung += "/0/0/0/0/0/0/0/0"; // polst die Nachricht mit Null -Bytes aus
// Speichern Sie das Ergebnis hier
result = "";
tempresult = "";
if (modus == 1) {// CBC -Modus
cbcleft = (iv.charcodeat (m ++) << 24) | (iv.charcodeat (m ++) << 16) | (iv.charcodeat (m ++) << 8) | IV.CharCodeat (M ++);
cbcright = (iv.charcodeat (m ++) << 24) | (iv.charcodeat (m ++) << 16) | (iv.charcodeat (m ++) << 8) | IV.CharCodeat (M ++);
M = 0;
}
// Schlagen Sie jeden 64 -Bit -Stück der Nachricht durch
während (m <len) {
links = (message.charCodeat (m ++) << 24) | (Message.charCodeat (M ++) << 16) | (Message.charCodeat (M ++) << 8) | message.charCodeat (M ++);
Right = (message.charCodeat (m ++) << 24) | (Message.charCodeat (M ++) << 16) | (Message.charCodeat (M ++) << 8) | message.charCodeat (M ++);
// Für den Verschlüsselungsblock -Kabinenmodus die Nachricht mit dem vorherigen Ergebnis xor
if (modus == 1) {if (Encrypt) {links ^= cbcleft; Right ^= cbcright;} else {cbcleft2 = cbcleft; CBCRIGHT2 = CBCRIGHT; cbcleft = links; cbcright = rechts;}}
// zuerst jeweils 64, aber ein Teil der Nachricht muss nach IP durchdrungen werden
temp = ((links >>> 4) ^ rechts) & 0x0f0f0f; rechts ^= temp; links ^= (temp << 4);
temp = ((links >>> 16) ^ rechts) & 0x0000ffff; rechts ^= temp; links ^= (temp << 16);
temp = (rechts >>> 2) ^ links) & 0x33333333; links ^= temp; rechts ^= (temp << 2);
temp = (rechts >>> 8) ^ links) & 0x00ff00ff; links ^= temp; rechts ^= (temp << 8);
temp = ((links >>> 1) ^ rechts) & 0x55555555; rechts ^= temp; links ^= (temp << 1);
links = ((links << 1) | (links >>> 31));
Right = ((rechts << 1) | (rechts >>> 31));
// Tun Sie dies entweder 1 oder dreimal für jeden Stück der Nachricht
für (j = 0; j <iterations; j+= 3) {
Endloop = Looping [j+1];
Loopinc = Looping [j+2];
// Gehen Sie nun durch und führen Sie die Verschlüsselung oder Entschlüsselung durch
für (i = Looping [j]; i! = endloop; i+= Loopinc) {// für Effizienz
Right1 = rechts ^ Schlüssel [i];
Right2 = ((rechts >>> 4) | (rechts << 28)) ^ Schlüssel [i+1];
// Das Ergebnis wird erreicht, indem diese Bytes durch die S -Auswahlfunktionen geleitet werden
temp = links;
links = rechts;
Right = temp ^ (spfunction2 [(rechts1 >>> 24) & 0x3f] | spfunction4 [(rechts1 >>> 16) & 0x3f]
| SPFunction6 [(rechts1 >>> 8) & 0x3f] | SPFUTICT8 [Right1 & 0x3f]
| SPFunction1 [(rechts2 >>> 24) & 0x3f] | SPFUTICT3 [(Right2 >>> 16) & 0x3f]
| SPFunction5 [(rechts2 >>> 8) & 0x3f] | SPFunction7 [Right2 & 0x3f]);
}
temp = links; links = rechts; rechts = temp; // unreverse links und rechts unreverse
} // für 1 oder 3 Iterationen
// Bewegen Sie sich dann jedes Bit nach rechts
links = ((links >>> 1) | (links << 31));
Right = ((rechts >>> 1) | (rechts << 31));
// Führen Sie nun IP-1 durch, das IP in der entgegengesetzten Richtung ist
temp = ((links >>> 1) ^ rechts) & 0x55555555; rechts ^= temp; links ^= (temp << 1);
temp = (rechts >>> 8) ^ links) & 0x00ff00ff; links ^= temp; rechts ^= (temp << 8);
temp = (rechts >>> 2) ^ links) & 0x33333333; links ^= temp; rechts ^= (temp << 2);
temp = ((links >>> 16) ^ rechts) & 0x0000ffff; rechts ^= temp; links ^= (temp << 16);
temp = ((links >>> 4) ^ rechts) & 0x0f0f0f; rechts ^= temp; links ^= (temp << 4);
// Für den Verschlüsselungsblock -Kabinenmodus die Nachricht mit dem vorherigen Ergebnis xor
if (modus == 1) {if (Encrypt) {cbcleft = links; cbcright = rechts;} else {links ^= cbcleft2; rechts ^= cbcright2;}}
temPresult += string.fromCharCode ((links >>> 24), (links >>> 16) & 0xff), (links >>> 8) & 0xff), (links & 0xff), (rechts >>> 24), (rechts >>> 16) & 0xff), (rechts >>> 8) & 0xff), (rechts & 0xff));
Chunk += 8;
if (chunk == 512) {result += tempresult; tempresult = ""; Chunk = 0;}
} // für alle 8 Zeichen oder 64 Bit in der Nachricht
// Geben Sie das Ergebnis als Array zurück
Rückgabeergebnis + Tempresult;
} // Ende von DES
// Des_CreateKeys
// Dies dauert eine Eingabe von 64 Bits (obwohl nur 56 Bit verwendet werden)
// als eine Reihe von 2 Ganzzahlen und gibt 16 48 -Bit -Tasten zurück
Funktion Des_CreateKeys (Schlüssel) {
// Das Deklarieren dieses lokalen beschleunigt die Dinge ein bisschen
pc2bytes0 = new Array (0,0x4,0x20000000,0x20000004,0x10000,0x10004,0x20010000,0x20010004,0x200,0x204,0x20000200,0x20000204,0x10200,0x10204,0x20010200,0x20010204);
PC2BYTES1 = Neues Array (0,0x1,0x100000.0x100001,0x4000000,0x4000001,0x4100000.0x4100001,0x100,0x101,0x100100.0x100101001001001001001001001001001001001001001001001001001001001001001001);
PC2BYTES2 = Neuarray (0,0x8.0x800,0x808,0x1000000,0x1000008,0x1000800,0x1000808,0,0x8,0x800,0x808,0x1000000, 0x1000008,0x1000800, 0x1000808);
pc2bytes3 = new Array (0,0x200000,0x8000000,0x8200000,0x2000,0x202000,0x8002000,0x8202000,0x20000,0x220000,0x8020000,0x8220000,0x22000,0x222000,0x8022000,0x8222000);
PC2BYTES4 = Neues Array (0,0x40000,0x10.0x40010,0,0 x 40000,0 x 10,0 x 40010,0x1000,0x41000,0x1010,0x41010,0x1000,0x41000,0x10101010));
PC2BYTES5 = Neuarray (0,0x400,0x20,0x420,0,0x400,0x20,0x420,0x20000,0x2000400,0x2002020,0x2000420,0x200000000,0x2000400,0x2000020,0x2000420);
PC2BYTES6 = Neues Array (0,0x10000000.0x80000,0x100800,0x2,0x100002,0x80002,0x10080002,0,0x10000000,0x80000,0x100000000,0x2.0x10000000,0x80002,0x1000002);
pc2bytes7 = new Array (0,0x10000,0x800,0x10800,0x20000000,0x20010000,0x20000800,0x20010800,0x20000,0x30000,0x20800,0x30800,0x20020000,0x20030000,0x20020800,0x20030800);
PC2BYTES8 = Neuarray (0,0x40000,0,0x400,0x2,0x40002,0x2,0x40002,0x20000,0x2040000,0x2000000,0x2040000,0x2000002,0x2040002,0x2000002000002000002000002000002000002000002, 0x2040002);
PC2BYTES9 = Neues Array (0,0x10000000,0x8.0x10000008,0,0x100000, 0x8.0x100008,0x400,0x10000400,0x408.0x10000408.0x400,0x100400400400, 0x40808, 0x1004);
PC2BYTES10 = Neuarray (0,0x20,0,0x20,0x100000,0x100020,0x100000,0x100020,0x2000,0x2020,0x2000,0x2020,0x102000,0x102020,0x2000,0x102020));
pc2bytes11 = new Array (0,0x1000000,0x200,0x1000200,0x200000,0x1200000,0x200200,0x1200200,0x4000000,0x5000000,0x4000200,0x5000200,0x4200000,0x5200000,0x4200200,0x5200200);
PC2BYTES12 = Neues Array (0,0x1000,0x8000000,0x8001000,0x800,0x81000,0x80800,0x8081000,0x10,0x1010,0x8000010, 0x80010, 0x80010, 0x810, 0x810);
pc2Bytes13 = Neuarray (0,0x4,0x100,0x104,0,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x1,0x5,0x101,0x105);
// wie viele Iterationen (1 für DES, 3 für Triple DES)
var iterations = key.length> 8? 3: 1; // geändert von Paul 16/6/2007, um Triple DES für 9+ Byte -Schlüssel zu verwenden
// speichert die Rückgabeschlüssel
var keys = new Array (32 * Iterationen);
// Definieren Sie nun die linken Verschiebungen, die durchgeführt werden müssen
var Verschiebungen = Neuarray (0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
// andere Variablen
var linksTemp, righttemp, m = 0, n = 0, temp;
für (var j = 0; j <iterations; j ++) {// entweder 1 oder 3 Iterationen
links = (key.charCodeat (m ++) << 24) | (key.charCodeat (m ++) << 16) | (key.charCodeat (M ++) << 8) | key.charCodeat (M ++);
Right = (key.charCodeat (m ++) << 24) | (key.charCodeat (m ++) << 16) | (key.charCodeat (M ++) << 8) | key.charCodeat (M ++);
temp = ((links >>> 4) ^ rechts) & 0x0f0f0f; rechts ^= temp; links ^= (temp << 4);
temp = (rechts >>> -16) ^ links) & 0x0000ffff; links ^= temp; rechts ^= (temp << -16);
temp = ((links >>> 2) ^ rechts) & 0x33333333; rechts ^= temp; links ^= (temp << 2);
temp = (rechts >>> -16) ^ links) & 0x0000ffff; links ^= temp; rechts ^= (temp << -16);
temp = ((links >>> 1) ^ rechts) & 0x55555555; rechts ^= temp; links ^= (temp << 1);
temp = (rechts >>> 8) ^ links) & 0x00ff00ff; links ^= temp; rechts ^= (temp << 8);
temp = ((links >>> 1) ^ rechts) & 0x55555555; rechts ^= temp; links ^= (temp << 1);
// Die rechte Seite muss verschoben werden und die letzten vier Teile der linken Seite bekommen
temp = (links << 8) | ((rechts >>> 20) & 0x000000f0);
// Links muss nach oben gesetzt werden
links = (rechts << 24) | ((rechts << 8) & 0xff0000) | ((rechts >>> 8) & 0xff00) | ((rechts >>> 24) & 0xf0);
rechts = temp;
// Gehen Sie nun durch und führen Sie diese Schichten auf den linken und rechten Tasten durch
für (var i = 0; i <Shifts.length; i ++) {
// Verschieben Sie die Schlüssel entweder ein oder zwei Teile nach links
if (verschiebt [i]) {links = (links << 2) | (links >>> 26); Right = (rechts << 2) | (rechts >>> 26);}
sonst {links = (links << 1) | (links >>> 27); Right = (rechts << 1) | (rechts >>> 27);}
links & = -0xf; rechts & = -0xf;
// Wenden Sie nun PC-2 an, so dass E beim Verschlingen oder Entschlüsseln einfacher ist
// Diese Konvertierung sieht wie PC-2 aus, außer dass nur die letzten 6 Bit jedes Byte verwendet werden
// anstelle von 48 aufeinanderfolgenden Bits und die Reihenfolge der Linien wird nach
// Wie die S -Auswahlfunktionen angewendet werden: S2, S4, S6, S8, S1, S3, S5, S7
linksTemp = pc2Bytes0 [links >>> 28] | pc2Bytes1 [(links >>> 24) & 0xf]
| pc2Bytes2 [(links >>> 20) & 0xf] | pc2Bytes3 [(links >>> 16) & 0xf]
| pc2Bytes4 [(links >>> 12) & 0xf] | pc2Bytes5 [(links >>> 8) & 0xf]
| pc2Bytes6 [(links >>> 4) & 0xf];
righttemp = pc2Bytes7 [rechts >>> 28] | pc2Bytes8 [(rechts >>> 24) & 0xf]
| pc2Bytes9 [(rechts >>> 20) & 0xf] | pc2Bytes10 [(rechts >>> 16) & 0xf]
| pc2Bytes11 [(rechts >>> 12) & 0xf] | pc2Bytes12 [(rechts >>> 8) & 0xf]
| pc2Bytes13 [(rechts >>> 4) & 0xf];
temp = ((righttemp >>> 16) ^ linksTemp) & 0x0000ffff;
Schlüssel [n ++] = linksTemp ^ temp; Schlüssel [n ++] = rightTemp ^ (temp << 16);
}
} // für jede Iterationen
// Geben Sie die Tasten zurück, die wir erstellt haben
Rückgabeschlüssel;
} // Ende von Des_CreateKeys
////////////////////////////// PRÜFEN /////////////////// //////////////
FunktionsstringTohex (s) {
var r = "0x";
var hexes = new Array ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a",. "B", "C", "D", "E", "F");
für (var i = 0; i <sength; i ++) {r += hexes [S. charCodeat (i) >> 4] +hexes [S. charCodeat (i) & 0xf];}
return r;
}
Funktion HextoString (h) {
var r = "";
für (var i = (h.substr (0, 2) == "0x")? 2: 0; i <H.Length; i += 2) {r += string.fromCharCode (parseInt (h.substr (i) , 2), 16));}
return r;
}
var key = "Dies ist ein 24 -Byte -Schlüssel !!";
var message = "Dies ist eine Testnachricht";
var ciphertext = Des (Schlüssel, Nachricht, 1, 0);
document.WriteLN ("Des test:" + stringTohex (Ciphertext));