JavaScript implements DES decryption encryption whole process _javascript skill

Source: Internet
Author: User
Copy Code code as follows:

Paul Tero, July 2001.
http://www.tero.co.uk/des/
//
Optimised for performance with large blocks by Michael Hayworth, November 2001
Http://www.netdealing.com
//
This SOFTWARE is provided ' as is ' and
Any EXPRESS OR implied warranties, including, BUT not LIMITED to, the
Implied warranties of merchantability and FITNESS for A particular purpose
ARE disclaimed. In NO EVENT SHALL the AUTHOR OR CONTRIBUTORS to be liable
For any DIRECT, INDIRECT, incidental, SPECIAL, exemplary, OR consequential
Damages (including, BUT not LIMITED to, procurement of substitute goods
or SERVICES; LOSS of Use, DATA, OR profits; OR BUSINESS Interruption)
HOWEVER caused and on any theory of liability, WHETHER in CONTRACT, STRICT
Liability, or TORT (including negligence or otherwise) arising in any WAY
Out of the "use" of this SOFTWARE, even IF advised of the possibility of
SUCH DAMAGE.

Des
This is takes the key, the message, and whether to encrypt or decrypt
Function des (key, message, encrypt, mode, IV, padding) {
Declaring this locally speeds things up a bit
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,0x10404,0x1010400,0x404,0x1000400,0x1000400,0,0x10004,0x10400, 0,0X1010004);
var spfunction2 = new Array ( -0x7fef7fe0,-0x7fff8000,0x8000,0x108020,0x100000,0x20,-0x7fefffe0,-0x7fff7fe0,- 0x7fffffe0,-0x7fef7fe0,-0x7fef8000,-0x80000000,-0x7fff8000,0x100000,0x20,-0x7fefffe0,0x108000,0x100020,- 0x7fff7fe0,0,-0x80000000,0x8000,0x108020,-0x7ff00000,0x100020,-0x7fffffe0,0,0x108000,0x8020,-0x7fef8000,- 0x7ff00000,0x8020,0,0x108020,-0x7fefffe0,0x100000,-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,0x20000,0x8000208,0x8,0x8020208,0x200,0x8000000,0x8020200,0x8000000,0x20008,0x208,0x20000, 0x8020200,0x8000200,0,0x200,0x20008,0x8020208,0x8000200,0x8000008,0x200,0,0x8020008,0x8000208,0x20000, 0x8000000,0x8020208,0x8,0x20208,0x20200,0x8000008,0x8020000,0x8000208,0x208,0x8020000,0x20208,0x8,0x8020008, 0X20200);
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,0x802081,0x81,0x800080,0x800001,0x802000,0x802081,0x81,0,0,0x802000,0x2080,0x800080, 0X800081,0X1,0X802001,0X2081,0X2081,0X80,0X802081,0X81,0X1,0X2000,0X800001,0X2001,0X802080,0X800081,0X2001, 0x2080,0x800000,0x802001,0x80,0x800000,0x2000,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,0x4000,0x20400000,0x404010, 0X4000,0X400010,0X20004010,0,0X20404000,0X20000000,0X400010,0X20004010);
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,0x2,0x4000000,0x200800,0x4000000,0x200800,0x200000,0x4000802 , 0x4000802,0x4200002,0x4200002,0x2,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,0x10001000,0x41040,0x40000,0x41040,0x40000, 0x10041000,0x1000,0x40,0x10040040,0x1000,0x41040,0x10001000,0x40,0x10000040,0x10040000,0x10040040,0x10000000, 0x40000,0x10001040,0,0x10041040,0x40040,0x10000040,0x10040000,0x10001000,0x10001040,0,0x10041040,0x41000, 0x41000,0x1040,0x1040,0x40040,0x10000000,0x10041000);

Create the or subkeys we'll need
var keys = Des_createkeys (key);
var m=0, I, J, temp, Temp2, right1, right2, left, right, looping;
var cbcleft, cbcleft2, Cbcright, cbcright2
var endloop, Loopinc;
var len = message.length;
var chunk = 0;
Set up the loops to single and Triple DES
var iterations = Keys.length = = 32? 3:9; Single or Triple DES
if (iterations = = 3) {looping = encrypt. New Array (0, 2): New Array (30,-2,-2);}
else {looping = encrypt? New Array (0, 2, 2, 2): New Array (94, 62,-2, 32, 64, 2, 30,-2,-2);}

Pad the message depending on the padding parameter
if (padding = = 2) message + = ""; Pad the message with spaces
else if (padding = = 1) {temp = 8-(len%8); Message + + String.fromCharCode (temp,temp,temp,temp,temp,temp,temp,temp); if (temp==8) len+=8;} PKCS7 padding
else if (!padding) message + = "\0\0\0\0\0\0\0\0"; Pad the message out with null bytes

Store the result
result = "";
Tempresult = "";

if (mode = = 1) {//CBC mode
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;
}

Loop through each chunk bit
while (M < Len) {
left = (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++);

For Cipher block Chaining mode, xor the "message" and the previous result
if (mode = = 1) {if (encrypt) {left ^= cbcleft, right ^= cbcright;} else {cbcleft2 = cbcleft; cbcright2 = cbcright; cbcleft = left; Cbcright = right;}

The But chunk of the the message must is permuted according to IP
Temp = (left >>> 4) ^ right) & 0x0f0f0f0f; Right ^= temp; Left ^= (temp << 4);
temp = ((left >>>) ^ right) & 0x0000ffff; Right ^= temp; Left ^= (temp << 16);
temp = ((right >>> 2) ^ left) & 0x33333333; Left ^= temp; Right ^= (temp << 2);
temp = ((right >>> 8) ^ left) & 0x00ff00ff; Left ^= temp; Right ^= (temp << 8);
Temp = (left >>> 1) ^ right) & 0x55555555; Right ^= temp; Left ^= (temp << 1);

left = (left << 1) | (left >>> 31));
right = ((right << 1) | (right >>> 31));

Do this either 1 or 3 is the chunk of the
For (j=0 j<iterations; j+=3) {
Endloop = looping[j+1];
Loopinc = looping[j+2];
Now go through and perform the encryption or decryption
for (I=LOOPING[J); I!=endloop i+=loopinc) {//for efficiency
right1 = right ^ keys[i];
Right2 = ((Right >>> 4) | (right << 28)) ^ keys[i+1];
The result are attained by passing these bytes through the S selection functions
temp = left;
left = right;
right = temp ^ (spfunction2[(right1 >>>) & 0x3f] | spfunction4[(right1 >>>) & 0x3f]
| spfunction6[(right1 >>> 8) & 0x3f] | Spfunction8[right1 & 0x3f]
| spfunction1[(right2 >>>) & 0x3f] | spfunction3[(right2 >>>) & 0x3f]
| spfunction5[(right2 >>> 8) & 0x3f] | Spfunction7[right2 & 0x3f]);
}
temp = left; left = right; right = temp; Unreverse left and right
}//for either 1 or 3 iterations

Move then a bit to the right
left = (left >>> 1) | (left << 31));
right = ((right >>> 1) | (right << 31));

Now perform IP-1, which are IP in the opposite direction
Temp = (left >>> 1) ^ right) & 0x55555555; Right ^= temp; Left ^= (temp << 1);
temp = ((right >>> 8) ^ left) & 0x00ff00ff; Left ^= temp; Right ^= (temp << 8);
temp = ((right >>> 2) ^ left) & 0x33333333; Left ^= temp; Right ^= (temp << 2);
temp = ((left >>>) ^ right) & 0x0000ffff; Right ^= temp; Left ^= (temp << 16);
Temp = (left >>> 4) ^ right) & 0x0f0f0f0f; Right ^= temp; Left ^= (temp << 4);

For Cipher block Chaining mode, xor the "message" and the previous result
if (mode = = 1) {if (encrypt) {cbcleft = left; cbcright = right;} else {left ^= cbcleft2; right ^= cbcright2;}}
Tempresult + + string.fromcharcode (left>>>24), ((left>>>16) & 0xFF), ((left>>>8) & 0xFF), (left & 0xFF), (right>>>24), ((right>>>16) & 0xFF), ((right>>>8) & 0xFF), ( Right & 0xFF));

Chunk + 8;
if (chunk = =) {result = Tempresult; tempresult = ""; Chunk = 0;}
}//for every 8 characters, or the bits in the message

Return the result as a array
return result + Tempresult;
}//end of Des



Des_createkeys
This is takes as input a bit key (even though only bits are used)
As an array of 2 integers, and returns bit keys
function Des_createkeys (key) {
Declaring this locally speeds things up a bit
Pc2bytes0 = new Array (0,0x4,0x20000000,0x20000004,0x10000,0x10004,0x20010000,0x20010004,0x200,0x204,0x20000200, 0x20000204,0x10200,0x10204,0x20010200,0x20010204);
Pc2bytes1 = new Array (0,0x1,0x100000,0x100001,0x4000000,0x4000001,0x4100000,0x4100001,0x100,0x101,0x100100, 0X100101,0X4000100,0X4000101,0X4100100,0X4100101);
Pc2bytes2 = new Array (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 = new Array (0,0x40000,0x10,0x40010,0,0x40000,0x10,0x40010,0x1000,0x41000,0x1010,0x41010,0x1000,0x41000, 0X1010,0X41010);
PC2BYTES5 = new Array (0,0x400,0x20,0x420,0,0x400,0x20,0x420,0x2000000,0x2000400,0x2000020,0x2000420,0x2000000, 0x2000400,0x2000020,0x2000420);
PC2BYTES6 = new Array (0,0x10000000,0x80000,0x10080000,0x2,0x10000002,0x80002,0x10080002,0,0x10000000,0x80000, 0X10080000,0X2,0X10000002,0X80002,0X10080002);
Pc2bytes7 = new Array (0,0x10000,0x800,0x10800,0x20000000,0x20010000,0x20000800,0x20010800,0x20000,0x30000,0x20800 , 0x30800,0x20020000,0x20030000,0x20020800,0x20030800);
Pc2bytes8 = new Array (0,0x40000,0,0x40000,0x2,0x40002,0x2,0x40002,0x2000000,0x2040000,0x2000000,0x2040000, 0X2000002,0X2040002,0X2000002,0X2040002);
PC2BYTES9 = new Array (0,0x10000000,0x8,0x10000008,0,0x10000000,0x8,0x10000008,0x400,0x10000400,0x408,0x10000408, 0x400,0x10000400,0x408,0x10000408);
PC2BYTES10 = new Array (0,0x20,0,0x20,0x100000,0x100020,0x100000,0x100020,0x2000,0x2020,0x2000,0x2020,0x102000, 0X102020,0X102000,0X102020);
PC2BYTES11 = new Array (0,0x1000000,0x200,0x1000200,0x200000,0x1200000,0x200200,0x1200200,0x4000000,0x5000000, 0X4000200,0X5000200,0X4200000,0X5200000,0X4200200,0X5200200);
PC2BYTES12 = new Array (0,0x1000,0x8000000,0x8001000,0x80000,0x81000,0x8080000,0x8081000,0x10,0x1010,0x8000010, 0X8001010,0X80010,0X81010,0X8080010,0X8081010);
PC2BYTES13 = new Array (0,0x4,0x100,0x104,0,0x4,0x100,0x104,0x1,0x5,0x101,0x105,0x1,0x5,0x101,0x105);

How to many iterations (1 for DES, 3 for Triple DES)
var iterations = key.length > 8? 3:1; Changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys
Stores the return keys
var keys = new Array (* iterations);
Now define the left shifts which need to being done
var shifts = new Array (0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
Other variables
var lefttemp, Righttemp, m=0, n=0, temp;

for (Var j=0 j<iterations; J + +) {//either 1 or 3 iterations
left = (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 = (left >>> 4) ^ right) & 0x0f0f0f0f; Right ^= temp; Left ^= (temp << 4);
temp = ((right >>> -16) ^ left) & 0x0000ffff; Left ^= temp; Right ^= (temp << 16);
Temp = (left >>> 2) ^ right) & 0x33333333; Right ^= temp; Left ^= (temp << 2);
temp = ((right >>> -16) ^ left) & 0x0000ffff; Left ^= temp; Right ^= (temp << 16);
Temp = (left >>> 1) ^ right) & 0x55555555; Right ^= temp; Left ^= (temp << 1);
temp = ((right >>> 8) ^ left) & 0x00ff00ff; Left ^= temp; Right ^= (temp << 8);
Temp = (left >>> 1) ^ right) & 0x55555555; Right ^= temp; Left ^= (temp << 1);

The right side needs is shifted and to get the last four bits of the left side
Temp = (left << 8) | (Right >>>) & 0x000000f0);
Left needs to is put upside down
left = (right << 24) | (Right << 8) & 0xff0000 | (Right >>> 8) & 0XFF00 | (Right >>>) & 0xf0);
right = temp;

Now go through and perform this shifts on the left and right keys
for (Var i=0 i < shifts.length; i++) {
Shift the keys either one or two bits to the left
if (Shifts[i]) {left = (left << 2) | (left >>> 26); right = (right << 2) | (right >>> 26);}
else {left = (left << 1) | (left >>> 27); right = (right << 1) | (right >>> 27);}
Left &= -0xf; Right &= -0xf;

Now apply PC-2, in such a way this E is easier when encrypting or decrypting
This conversion would look like PC-2 except only to the last 6 bits in each byte are used
Rather than consecutive bits and the order of lines is according to
How the S selection functions'll be applied:s2, S4, S6, S8, S1, S3, S5, S7
Lefttemp = Pc2bytes0[left >>> 28] | pc2bytes1[(left >>>) & 0xf]
| pc2bytes2[(left >>>) & 0xf] | pc2bytes3[(left >>>) & 0xf]
| pc2bytes4[(left >>>) & 0xf] | pc2bytes5[(left >>> 8) & 0XF]
| Pc2bytes6[(left >>> 4) & 0xf];
Righttemp = Pc2bytes7[right >>> 28] | pc2bytes8[(right >>>) & 0xf]
| pc2bytes9[(right >>>) & 0xf] | pc2bytes10[(right >>>) & 0xf]
| pc2bytes11[(right >>>) & 0xf] | pc2bytes12[(right >>> 8) & 0XF]
| pc2bytes13[(Right >>> 4) & 0xf];
temp = ((righttemp >>>) ^ lefttemp) & 0x0000ffff;
keys[n++] = lefttemp ^ temp; keys[n++] = righttemp ^ (temp << 16);
}
}//for each iterations
Return the keys we ' ve created
return keys;
}//end of Des_createkeys



TEST//////////////////////////////
function Stringtohex (s) {
var r = "0x";
var hexes = new Array ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "B", "C", "D", "E", "F");
for (var i=0 i<s.length; i++) {r = hexes [S.charcodeat (i) >> 4] + hexes [S.charcodeat (i) & 0xf];}
return R;
}

function hextostring (h) {
var r = "";
For (Var i= (h.substr (0, 2) = = "0x")? 2:0 ireturn R;
}

var key = "This is a byte key!!";
var message = ' This is ' a test message ';
var ciphertext = des (key, message, 1, 0);
Document.writeln ("DES Test:" + stringtohex (ciphertext));
Related Article

E-Commerce Solutions

Leverage the same tools powering the Alibaba Ecosystem

Learn more >

Apsara Conference 2019

The Rise of Data Intelligence, September 25th - 27th, Hangzhou, China

Learn more >

Alibaba Cloud Free Trial

Learn and experience the power of Alibaba Cloud with a free trial worth $300-1200 USD

Learn more >

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.