devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JS 实现AES方式加密数据实现示例

作者：你好赵伟 | 2024-03-09 01:58:29

赞

踩

JS 实现AES方式加密数据实现示例
简介：
     全称高级加密标准（英文名称：Advanced Encryption Standard），在密码学中又称 Rijndael 加密法，由美国国家标准与技术研究院 （NIST）于 2001 年发布，并在 2002 年成为有效的标准，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的 DES，已经被多方分析且广为全世界所使用，它本身只有一个密钥，即用来实现加密，也用于解密。

- mode 支持：CBC，CFB，CTR，CTRGladman，ECB，OFB 等。
- padding 支持：ZeroPadding，NoPadding，AnsiX923，Iso10126，Iso97971，Pkcs7 等
- **CFB模式** 全称Cipher FeedBack模式，译为密文反馈模式

- **OFB模式** 全称Output Feedback模式，译为输出反馈模式。

- **CTR模式** 全称Counter模式，译为计数器模式。

- **iv:** 防止同样的明文块、加密成同样的密文块

参数定义：

  1. key length（密钥位数，密码长度）AES128，AES192，AES256（128 位、192 位或 256 位）
  2. key （密钥，密码）key指的就是密码了，AES128就是128位的，如果位数不够，某些库可能会自动填充到128。
  3. IV （向量）IV称为初始向量，不同的IV加密后的字符串是不同的，加密和解密需要相同的IV。
  4. mode （加密模式）AES分为几种模式，比如ECB，CBC，CFB等等，这些模式除了ECB由于没有使用IV而不太安全，其他模式差别并没有太明显。
  5. padding （填充方式）对于加密解密两端需要使用同一的PADDING模式，大部分PADDING模式为PKCS5, PKCS7, NOPADDING。

加密原理：

​         AES加密算法采用分组密码体制，每个分组数据的长度为128位16个字节，密钥长度可以是128位16个字节、192位或256位，一共有四种加密模式，我们通常采用需要初始向量IV的CBC模式，初始向量的长度也是128位16个字节。

  1.  
  2. //des
  3. //this takes the key, the message, and whether to encrypt or decrypt
  4. function des(key, message, encrypt, mode, iv, padding) {
  5.   //declaring this locally speeds things up a bit
  6.   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);
  7.   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);
  8.   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);
  9.   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);
  10.   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);
  11.   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);
  12.   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);
  13.   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);
  14.  
  15.   //create the 16 or 48 subkeys we will need
  16.   var keys = des_createKeys(key);
  17.   var m = 0, i, j, temp, temp2, right1, right2, left, right, looping;
  18.   var cbcleft, cbcleft2, cbcright, cbcright2
  19.   var endloop, loopinc;
  20.   var len = message.length;
  21.   var chunk = 0;
  22.   //set up the loops for single and triple des
  23.   var iterations = keys.length == 32 ? 3 : 9; //single or triple des
  24.   if (iterations == 3) {looping = encrypt ? new Array(0, 32, 2) : new Array(30, -2, -2);}
  25.   else {looping = encrypt ? new Array(0, 32, 2, 62, 30, -2, 64, 96, 2) : new Array(94, 62, -2, 32, 64, 2, 30, -2, -2);}
  26.  
  27.   //pad the message depending on the padding parameter
  28.   if (padding == 2) message += "        "; //pad the message with spaces
  29.   else if (padding == 1) {
  30.       temp = 8 - (len % 8);
  31.       message += String.fromCharCode(temp, temp, temp, temp, temp, temp, temp, temp);
  32.       if (temp == 8) len += 8;
  33.   } //PKCS7 padding
  34.   else if (!padding) message += "\0\0\0\0\0\0\0\0"; //pad the message out with null bytes
  35.  
  36.   //store the result here
  37.   var result = "";
  38.   var tempresult = "";
  39.  
  40.   if (mode == 1) { //CBC mode
  41.       cbcleft = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
  42.       cbcright = (iv.charCodeAt(m++) << 24) | (iv.charCodeAt(m++) << 16) | (iv.charCodeAt(m++) << 8) | iv.charCodeAt(m++);
  43.       m = 0;
  44.   }
  45.  
  46.   //loop through each 64 bit chunk of the message
  47.   while (m < len) {
  48.       left = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
  49.       right = (message.charCodeAt(m++) << 24) | (message.charCodeAt(m++) << 16) | (message.charCodeAt(m++) << 8) | message.charCodeAt(m++);
  50.  
  51.       //for Cipher Block Chaining mode, xor the message with the previous result
  52.       if (mode == 1) {
  53.           if (encrypt) {
  54.               left ^= cbcleft;
  55.               right ^= cbcright;
  56.           } else {
  57.               cbcleft2 = cbcleft;
  58.               cbcright2 = cbcright;
  59.               cbcleft = left;
  60.               cbcright = right;
  61.           }
  62.       }
  63.  
  64.       //first each 64 but chunk of the message must be permuted according to IP
  65.       temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
  66.       right ^= temp;
  67.       left ^= (temp << 4);
  68.       temp = ((left >>> 16) ^ right) & 0x0000ffff;
  69.       right ^= temp;
  70.       left ^= (temp << 16);
  71.       temp = ((right >>> 2) ^ left) & 0x33333333;
  72.       left ^= temp;
  73.       right ^= (temp << 2);
  74.       temp = ((right >>> 8) ^ left) & 0x00ff00ff;
  75.       left ^= temp;
  76.       right ^= (temp << 8);
  77.       temp = ((left >>> 1) ^ right) & 0x55555555;
  78.       right ^= temp;
  79.       left ^= (temp << 1);
  80.  
  81.       left = ((left << 1) | (left >>> 31));
  82.       right = ((right << 1) | (right >>> 31));
  83.  
  84.       //do this either 1 or 3 times for each chunk of the message
  85.       for (j = 0; j < iterations; j += 3) {
  86.           endloop = looping[j + 1];
  87.           loopinc = looping[j + 2];
  88.           //now go through and perform the encryption or decryption  
  89.           for (i = looping[j]; i != endloop; i += loopinc) { //for efficiency
  90.               right1 = right ^ keys[i];
  91.               right2 = ((right >>> 4) | (right << 28)) ^ keys[i + 1];
  92.               //the result is attained by passing these bytes through the S selection functions
  93.               temp = left;
  94.               left = right;
  95.               right = temp ^ (spfunction2[(right1 >>> 24) & 0x3f] | spfunction4[(right1 >>> 16) & 0x3f]
  96.                   | spfunction6[(right1 >>> 8) & 0x3f] | spfunction8[right1 & 0x3f]
  97.                   | spfunction1[(right2 >>> 24) & 0x3f] | spfunction3[(right2 >>> 16) & 0x3f]
  98.                   | spfunction5[(right2 >>> 8) & 0x3f] | spfunction7[right2 & 0x3f]);
  99.           }
  100.           temp = left;
  101.           left = right;
  102.           right = temp; //unreverse left and right
  103.       } //for either 1 or 3 iterations
  104.  
  105.       //move then each one bit to the right
  106.       left = ((left >>> 1) | (left << 31));
  107.       right = ((right >>> 1) | (right << 31));
  108.  
  109.       //now perform IP-1, which is IP in the opposite direction
  110.       temp = ((left >>> 1) ^ right) & 0x55555555;
  111.       right ^= temp;
  112.       left ^= (temp << 1);
  113.       temp = ((right >>> 8) ^ left) & 0x00ff00ff;
  114.       left ^= temp;
  115.       right ^= (temp << 8);
  116.       temp = ((right >>> 2) ^ left) & 0x33333333;
  117.       left ^= temp;
  118.       right ^= (temp << 2);
  119.       temp = ((left >>> 16) ^ right) & 0x0000ffff;
  120.       right ^= temp;
  121.       left ^= (temp << 16);
  122.       temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
  123.       right ^= temp;
  124.       left ^= (temp << 4);
  125.  
  126.       //for Cipher Block Chaining mode, xor the message with the previous result
  127.       if (mode == 1) {
  128.           if (encrypt) {
  129.               cbcleft = left;
  130.               cbcright = right;
  131.           } else {
  132.               left ^= cbcleft2;
  133.               right ^= cbcright2;
  134.           }
  135.       }
  136.       tempresult += String.fromCharCode((left >>> 24), ((left >>> 16) & 0xff), ((left >>> 8) & 0xff), (left & 0xff), (right >>> 24), ((right >>> 16) & 0xff), ((right >>> 8) & 0xff), (right & 0xff));
  137.  
  138.       chunk += 8;
  139.       if (chunk == 512) {
  140.           result += tempresult;
  141.           tempresult = "";
  142.           chunk = 0;
  143.       }
  144.   } //for every 8 characters, or 64 bits in the message
  145.  
  146.   //return the result as an array
  147.   return result + tempresult;
  148. } //end of des
  149.  
  150.  
  151. //des_createKeys
  152. //this takes as input a 64 bit key (even though only 56 bits are used)
  153. //as an array of 2 integers, and returns 16 48 bit keys
  154. function des_createKeys(key) {
  155.   //declaring this locally speeds things up a bit
  156.   var pc2bytes0 = new Array(0, 0x4, 0x20000000, 0x20000004, 0x10000, 0x10004, 0x20010000, 0x20010004, 0x200, 0x204, 0x20000200, 0x20000204, 0x10200, 0x10204, 0x20010200, 0x20010204);
  157.   var pc2bytes1 = new Array(0, 0x1, 0x100000, 0x100001, 0x4000000, 0x4000001, 0x4100000, 0x4100001, 0x100, 0x101, 0x100100, 0x100101, 0x4000100, 0x4000101, 0x4100100, 0x4100101);
  158.   var pc2bytes2 = new Array(0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808, 0, 0x8, 0x800, 0x808, 0x1000000, 0x1000008, 0x1000800, 0x1000808);
  159.   var pc2bytes3 = new Array(0, 0x200000, 0x8000000, 0x8200000, 0x2000, 0x202000, 0x8002000, 0x8202000, 0x20000, 0x220000, 0x8020000, 0x8220000, 0x22000, 0x222000, 0x8022000, 0x8222000);
  160.   var pc2bytes4 = new Array(0, 0x40000, 0x10, 0x40010, 0, 0x40000, 0x10, 0x40010, 0x1000, 0x41000, 0x1010, 0x41010, 0x1000, 0x41000, 0x1010, 0x41010);
  161.   var pc2bytes5 = new Array(0, 0x400, 0x20, 0x420, 0, 0x400, 0x20, 0x420, 0x2000000, 0x2000400, 0x2000020, 0x2000420, 0x2000000, 0x2000400, 0x2000020, 0x2000420);
  162.   var pc2bytes6 = new Array(0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002, 0, 0x10000000, 0x80000, 0x10080000, 0x2, 0x10000002, 0x80002, 0x10080002);
  163.   var pc2bytes7 = new Array(0, 0x10000, 0x800, 0x10800, 0x20000000, 0x20010000, 0x20000800, 0x20010800, 0x20000, 0x30000, 0x20800, 0x30800, 0x20020000, 0x20030000, 0x20020800, 0x20030800);
  164.   var pc2bytes8 = new Array(0, 0x40000, 0, 0x40000, 0x2, 0x40002, 0x2, 0x40002, 0x2000000, 0x2040000, 0x2000000, 0x2040000, 0x2000002, 0x2040002, 0x2000002, 0x2040002);
  165.   var pc2bytes9 = new Array(0, 0x10000000, 0x8, 0x10000008, 0, 0x10000000, 0x8, 0x10000008, 0x400, 0x10000400, 0x408, 0x10000408, 0x400, 0x10000400, 0x408, 0x10000408);
  166.   var pc2bytes10 = new Array(0, 0x20, 0, 0x20, 0x100000, 0x100020, 0x100000, 0x100020, 0x2000, 0x2020, 0x2000, 0x2020, 0x102000, 0x102020, 0x102000, 0x102020);
  167.   var pc2bytes11 = new Array(0, 0x1000000, 0x200, 0x1000200, 0x200000, 0x1200000, 0x200200, 0x1200200, 0x4000000, 0x5000000, 0x4000200, 0x5000200, 0x4200000, 0x5200000, 0x4200200, 0x5200200);
  168.   var pc2bytes12 = new Array(0, 0x1000, 0x8000000, 0x8001000, 0x80000, 0x81000, 0x8080000, 0x8081000, 0x10, 0x1010, 0x8000010, 0x8001010, 0x80010, 0x81010, 0x8080010, 0x8081010);
  169.   var pc2bytes13 = new Array(0, 0x4, 0x100, 0x104, 0, 0x4, 0x100, 0x104, 0x1, 0x5, 0x101, 0x105, 0x1, 0x5, 0x101, 0x105);
  170.  
  171.   //how many iterations (1 for des, 3 for triple des)
  172.   var iterations = key.length > 8 ? 3 : 1; //changed by Paul 16/6/2007 to use Triple DES for 9+ byte keys
  173.   //stores the return keys
  174.   var keys = new Array(32 * iterations);
  175.   //now define the left shifts which need to be done
  176.   var shifts = new Array(0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0);
  177.   //other variables
  178.   var lefttemp, righttemp, m = 0, n = 0, temp, left, right;
  179.  
  180.   for (var j = 0; j < iterations; j++) { //either 1 or 3 iterations
  181.       left = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
  182.       right = (key.charCodeAt(m++) << 24) | (key.charCodeAt(m++) << 16) | (key.charCodeAt(m++) << 8) | key.charCodeAt(m++);
  183.  
  184.       temp = ((left >>> 4) ^ right) & 0x0f0f0f0f;
  185.       right ^= temp;
  186.       left ^= (temp << 4);
  187.       temp = ((right >>> -16) ^ left) & 0x0000ffff;
  188.       left ^= temp;
  189.       right ^= (temp << -16);
  190.       temp = ((left >>> 2) ^ right) & 0x33333333;
  191.       right ^= temp;
  192.       left ^= (temp << 2);
  193.       temp = ((right >>> -16) ^ left) & 0x0000ffff;
  194.       left ^= temp;
  195.       right ^= (temp << -16);
  196.       temp = ((left >>> 1) ^ right) & 0x55555555;
  197.       right ^= temp;
  198.       left ^= (temp << 1);
  199.       temp = ((right >>> 8) ^ left) & 0x00ff00ff;
  200.       left ^= temp;
  201.       right ^= (temp << 8);
  202.       temp = ((left >>> 1) ^ right) & 0x55555555;
  203.       right ^= temp;
  204.       left ^= (temp << 1);
  205.  
  206.       //the right side needs to be shifted and to get the last four bits of the left side
  207.       temp = (left << 8) | ((right >>> 20) & 0x000000f0);
  208.       //left needs to be put upside down
  209.       left = (right << 24) | ((right << 8) & 0xff0000) | ((right >>> 8) & 0xff00) | ((right >>> 24) & 0xf0);
  210.       right = temp;
  211.  
  212.       //now go through and perform these shifts on the left and right keys
  213.       for (var i = 0; i < shifts.length; i++) {
  214.           //shift the keys either one or two bits to the left
  215.           if (shifts[i]) {
  216.               left = (left << 2) | (left >>> 26);
  217.               right = (right << 2) | (right >>> 26);
  218.           }
  219.           else {
  220.               left = (left << 1) | (left >>> 27);
  221.               right = (right << 1) | (right >>> 27);
  222.           }
  223.           left &= -0xf;
  224.           right &= -0xf;
  225.  
  226.           //now apply PC-2, in such a way that E is easier when encrypting or decrypting
  227.           //this conversion will look like PC-2 except only the last 6 bits of each byte are used
  228.           //rather than 48 consecutive bits and the order of lines will be according to 
  229.           //how the S selection functions will be applied: S2, S4, S6, S8, S1, S3, S5, S7
  230.           lefttemp = pc2bytes0[left >>> 28] | pc2bytes1[(left >>> 24) & 0xf]
  231.               | pc2bytes2[(left >>> 20) & 0xf] | pc2bytes3[(left >>> 16) & 0xf]
  232.               | pc2bytes4[(left >>> 12) & 0xf] | pc2bytes5[(left >>> 8) & 0xf]
  233.               | pc2bytes6[(left >>> 4) & 0xf];
  234.           righttemp = pc2bytes7[right >>> 28] | pc2bytes8[(right >>> 24) & 0xf]
  235.               | pc2bytes9[(right >>> 20) & 0xf] | pc2bytes10[(right >>> 16) & 0xf]
  236.               | pc2bytes11[(right >>> 12) & 0xf] | pc2bytes12[(right >>> 8) & 0xf]
  237.               | pc2bytes13[(right >>> 4) & 0xf];
  238.           temp = ((righttemp >>> 16) ^ lefttemp) & 0x0000ffff;
  239.           keys[n++] = lefttemp ^ temp;
  240.           keys[n++] = righttemp ^ (temp << 16);
  241.       }
  242.   } //for each iterations
  243.   //return the keys we've created
  244.   return keys;
  245. } //end of des_createKeys
  246.  
  247.  
  248. var encodeHex = (s) => {
  249.   let r = '';
  250.   const hexes = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f');
  251.   for (let i = 0; i < s.length; i++) {r += hexes [s.charCodeAt(i) >> 4] + hexes [s.charCodeAt(i) & 0xf];}
  252.   return r;
  253. }
  254.  
  255. function decodeHex(h) {
  256.   let r = '';
  257.   for (let i = (h.substring(0, 2) === '0x') ? 2 : 0; i < h.length; i += 2) {
  258.     r += String.fromCharCode(parseInt(h.substring(i, i + 2), 16));
  259.   }
  260.   return r;
  261. }
  262.  
  263.  
  264.  
  265. //
  266. // 参数说明
  267. /
  268. // key      加密密钥
  269. // message  加密/解密内容
  270. // type     类型
  271. //    加密 0
  272. //    解密 1  
  273. // mode     加密模式
  274. //    ECB：0
  275. //    CBC：1
  276. // iv       密钥向量
  277. //    undefined
  278. //    null
  279. //    ''
  280. // padding  加密填充
  281. //    NULL：  0
  282. //    PKCS7： 1
  283. //    SPACES：2
  284. //    NONE：  3
  285.  
  286. var key = "ZmserbBoHQtNP+wOcza/LpngG8yJq42KWYj0DSfdikx3VT16IlUAFM97hECvuRX5";
  287. var message = '{"x33":"0","x34":"0","x35":"0","x36":"3","x37":"0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0","x38":"0|0|1|0|1|0|0|0|0|0|1|0|1|0|1|0|0|0|0|0|0|0","x39":"6","x42":"3.2.9","x43":"532ce42c","x44":"1709601827528","x45":"connecterror","x46":"false","x48":"","x49":"{list:[],type:}"}';
  288.  
  289. // des(key, message, type, mode, iv, padding)
  290. var strEnc = encodeHex( des( key, message, 0, 0, undefined, 0 ) );
  291. console.log( strEnc )
  292.  
  293. //  des(key, decodeHex(message), type, mode, iv, padding).replace(/\0/g, '')
  294. var strDec = des(key, decodeHex( strEnc ), 1, 0, key, 0).replace(/\0/g, '');
  295. console.log( strDec )

调用示例

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/213322
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号