实验内容

掌握分组密码算法DES方法,能用高级语言实现分组密码算法DESDES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组密钥长64位,密钥事实上是56位参与DES运算(第816243240485664位是校验位, 使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

2  分组密码算法DES算法的基本原理

其入口参数有三个:keydatamode key为加密解密使用的密钥,data为加密  des算法结构解密的数据,mode为其工作模式。当模式为加密模式时,明文按照64位进行分组,形成明文组,key用于对数据加密,当模式为解密模式时,key用于对数据解密。实际运用中,密钥只用到了64位中的56位,这样才具有高的安全性

2.1  分组密码算法DES算法概述

 

2.2  分组密码算法DES算法流程

DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位,整个算法  des算法流程图的主流程图如下

 

 

 

3. 实验结果 

 

 

全部源代码下载:

http://down.51cto.com/data/433704

部分源代码:

//密钥

 


  1. public class GetSubKey { 
  2.     private String inKey; 
  3.  
  4.     private StringBuffer keyBuf; 
  5.  
  6.     private byte[] key = new byte[64]; // 保存密钥的64位二进制表示 
  7.  
  8.     private byte[] kwork = new byte[56]; 
  9.  
  10.     private static byte[] shift = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 
  11.             2, 1 }; 
  12.  
  13.     protected byte[] k1 = new byte[48]; 
  14.  
  15.     protected byte[] k2 = new byte[48]; 
  16.  
  17.     protected byte[] k3 = new byte[48]; 
  18.  
  19.     protected byte[] k4 = new byte[48]; 
  20.  
  21.     protected byte[] k5 = new byte[48]; 
  22.  
  23.     protected byte[] k6 = new byte[48]; 
  24.  
  25.     protected byte[] k7 = new byte[48]; 
  26.  
  27.     protected byte[] k8 = new byte[48]; 
  28.  
  29.     protected byte[] k9 = new byte[48]; 
  30.  
  31.     protected byte[] k10 = new byte[48]; 
  32.  
  33.     protected byte[] k11 = new byte[48]; 
  34.  
  35.     protected byte[] k12 = new byte[48]; 
  36.  
  37.     protected byte[] k13 = new byte[48]; 
  38.  
  39.     protected byte[] k14 = new byte[48]; 
  40.  
  41.     protected byte[] k15 = new byte[48]; 
  42.  
  43.     protected byte[] k16 = new byte[48]; 
  44.  
  45.     protected byte[] kn = new byte[48]; 
  46.  
  47.     public GetSubKey(String inKey) { 
  48.         byte j; 
  49.         this.inKey = inKey; 
  50.         int len = inKey.length(); 
  51.         keyBuf = new StringBuffer(inKey); 
  52.         if (len < 8) { // 密钥必须是8位,若小于8位不够的补空格 ,大于8位取前8位 
  53.             for (int i = 1; i <= 8 - len; i++) 
  54.                 keyBuf.append("?"); 
  55.         } 
  56.         inKey = keyBuf.toString(); 
  57.         // 将8个字符的密钥转换成64位二进制表示 
  58.         for (int i = 0; i < 8; i++) { 
  59.             j = (byte) (inKey.charAt(i)); 
  60.             key[8 * i] = (byte) ((j / 128) % 2); 
  61.             key[8 * i + 1] = (byte) ((j / 64) % 2); 
  62.             key[8 * i + 2] = (byte) ((j / 32) % 2); 
  63.             key[8 * i + 3] = (byte) ((j / 16) % 2); 
  64.             key[8 * i + 4] = (byte) ((j / 8) % 2); 
  65.             key[8 * i + 5] = (byte) ((j / 4) % 2); 
  66.             key[8 * i + 6] = (byte) ((j / 2) % 2); 
  67.             key[8 * i + 7] = (byte) (j % 2); 
  68.         } 
  69.         // 初始化键的排列顺序 
  70.         kwork[0] = key[56]; 
  71.         kwork[1] = key[48]; 
  72.         kwork[2] = key[40]; 
  73.         kwork[3] = key[32]; 
  74.         kwork[4] = key[24]; 
  75.         kwork[5] = key[16]; 
  76.         kwork[6] = key[8]; 
  77.         kwork[7] = key[0]; 
  78.         kwork[8] = key[57]; 
  79.         kwork[9] = key[49]; 
  80.         kwork[10] = key[41]; 
  81.         kwork[11] = key[33]; 
  82.         kwork[12] = key[25]; 
  83.         kwork[13] = key[17]; 
  84.         kwork[14] = key[9]; 
  85.         kwork[15] = key[1]; 
  86.         kwork[16] = key[58]; 
  87.         kwork[17] = key[50]; 
  88.         kwork[18] = key[42]; 
  89.         kwork[19] = key[34]; 
  90.         kwork[20] = key[26]; 
  91.         kwork[21] = key[18]; 
  92.         kwork[22] = key[10]; 
  93.         kwork[23] = key[2]; 
  94.         kwork[24] = key[59]; 
  95.         kwork[25] = key[51]; 
  96.         kwork[26] = key[43]; 
  97.         kwork[27] = key[35]; 
  98.         kwork[28] = key[62]; 
  99.         kwork[29] = key[54]; 
  100.         kwork[30] = key[46]; 
  101.         kwork[31] = key[38]; 
  102.         kwork[32] = key[30]; 
  103.         kwork[33] = key[22]; 
  104.         kwork[34] = key[14]; 
  105.         kwork[35] = key[6]; 
  106.         kwork[36] = key[61]; 
  107.         kwork[37] = key[53]; 
  108.         kwork[38] = key[45]; 
  109.         kwork[39] = key[37]; 
  110.         kwork[40] = key[29]; 
  111.         kwork[41] = key[21]; 
  112.         kwork[42] = key[13]; 
  113.         kwork[43] = key[5]; 
  114.         kwork[44] = key[60]; 
  115.         kwork[45] = key[52]; 
  116.         kwork[46] = key[44]; 
  117.         kwork[47] = key[36]; 
  118.         kwork[48] = key[28]; 
  119.         kwork[49] = key[20]; 
  120.         kwork[50] = key[12]; 
  121.         kwork[51] = key[4]; 
  122.         kwork[52] = key[27]; 
  123.         kwork[53] = key[19]; 
  124.         kwork[54] = key[11]; 
  125.         kwork[55] = key[3]; 
  126.  
  127.         /* 开始计算子键 */ 
  128.         byte nbrofshift; 
  129.         byte temp1, temp2; 
  130.         for (int iter = 0; iter < 16; iter++) { 
  131.             nbrofshift = shift[iter]; 
  132.             for (int i = 0; i < (int) nbrofshift; i++) { 
  133.                 temp1 = kwork[0]; 
  134.                 temp2 = kwork[28]; 
  135.                 for (int k = 0; k < 27; k++) { 
  136.                     kwork[k] = kwork[k + 1]; 
  137.                     kwork[k + 28] = kwork[k + 29]; 
  138.                 } 
  139.                 kwork[27] = temp1; 
  140.                 kwork[55] = temp2; 
  141.             } 
  142.             /* Permute kwork - PC2 */ 
  143.             kn[0] = kwork[13]; 
  144.             kn[1] = kwork[16]; 
  145.             kn[2] = kwork[10]; 
  146.             kn[3] = kwork[23]; 
  147.             kn[4] = kwork[0]; 
  148.             kn[5] = kwork[4]; 
  149.             kn[6] = kwork[2]; 
  150.             kn[7] = kwork[27]; 
  151.             kn[8] = kwork[14]; 
  152.             kn[9] = kwork[5]; 
  153.             kn[10] = kwork[20]; 
  154.             kn[11] = kwork[9]; 
  155.             kn[12] = kwork[22]; 
  156.             kn[13] = kwork[18]; 
  157.             kn[14] = kwork[11]; 
  158.             kn[15] = kwork[3]; 
  159.             kn[16] = kwork[25]; 
  160.             kn[17] = kwork[7]; 
  161.             kn[18] = kwork[15]; 
  162.             kn[19] = kwork[6]; 
  163.             kn[20] = kwork[26]; 
  164.             kn[21] = kwork[19]; 
  165.             kn[22] = kwork[12]; 
  166.             kn[23] = kwork[1]; 
  167.             kn[24] = kwork[40]; 
  168.             kn[25] = kwork[51]; 
  169.             kn[26] = kwork[30]; 
  170.             kn[27] = kwork[36]; 
  171.             kn[28] = kwork[46]; 
  172.             kn[29] = kwork[54]; 
  173.             kn[30] = kwork[29]; 
  174.             kn[31] = kwork[39]; 
  175.             kn[32] = kwork[50]; 
  176.             kn[33] = kwork[44]; 
  177.             kn[34] = kwork[32]; 
  178.             kn[35] = kwork[47]; 
  179.             kn[36] = kwork[43]; 
  180.             kn[37] = kwork[48]; 
  181.             kn[38] = kwork[38]; 
  182.             kn[39] = kwork[55]; 
  183.             kn[40] = kwork[33]; 
  184.             kn[41] = kwork[52]; 
  185.             kn[42] = kwork[45]; 
  186.             kn[43] = kwork[41]; 
  187.             kn[44] = kwork[49]; 
  188.             kn[45] = kwork[35]; 
  189.             kn[46] = kwork[28]; 
  190.             kn[47] = kwork[31]; 
  191.  
  192.             switch (iter) { 
  193.             case 0: 
  194.                 for (int k = 0; k < 48; k++) { 
  195.                     k1[k] = kn[k]; 
  196.                 } 
  197.                 break; 
  198.             case 1: 
  199.                 for (int k = 0; k < 48; k++) { 
  200.                     k2[k] = kn[k]; 
  201.                 } 
  202.                 break; 
  203.             case 2: 
  204.                 for (int k = 0; k < 48; k++) { 
  205.                     k3[k] = kn[k]; 
  206.                 } 
  207.                 break; 
  208.             case 3: 
  209.                 for (int k = 0; k < 48; k++) { 
  210.                     k4[k] = kn[k]; 
  211.                 } 
  212.                 break; 
  213.             case 4: 
  214.                 for (int k = 0; k < 48; k++) { 
  215.                     k5[k] = kn[k]; 
  216.                 } 
  217.                 break; 
  218.             case 5: 
  219.                 for (int k = 0; k < 48; k++) { 
  220.                     k6[k] = kn[k]; 
  221.                 } 
  222.                 break; 
  223.             case 6: 
  224.                 for (int k = 0; k < 48; k++) { 
  225.                     k7[k] = kn[k]; 
  226.                 } 
  227.                 break; 
  228.             case 7: 
  229.                 for (int k = 0; k < 48; k++) { 
  230.                     k8[k] = kn[k]; 
  231.                 } 
  232.                 break; 
  233.             case 8: 
  234.                 for (int k = 0; k < 48; k++) { 
  235.                     k9[k] = kn[k]; 
  236.                 } 
  237.                 break; 
  238.             case 9: 
  239.                 for (int k = 0; k < 48; k++) { 
  240.                     k10[k] = kn[k]; 
  241.                 } 
  242.                 break; 
  243.             case 10: 
  244.                 for (int k = 0; k < 48; k++) { 
  245.                     k11[k] = kn[k]; 
  246.                 } 
  247.                 break; 
  248.             case 11: 
  249.                 for (int k = 0; k < 48; k++) { 
  250.                     k12[k] = kn[k]; 
  251.                 } 
  252.                 break; 
  253.             case 12: 
  254.                 for (int k = 0; k < 48; k++) { 
  255.                     k13[k] = kn[k]; 
  256.                 } 
  257.                 break; 
  258.             case 13: 
  259.                 for (int k = 0; k < 48; k++) { 
  260.                     k14[k] = kn[k]; 
  261.                 } 
  262.                 break; 
  263.             case 14: 
  264.                 for (int k = 0; k < 48; k++) { 
  265.                     k15[k] = kn[k]; 
  266.                 } 
  267.                 break; 
  268.             case 15: 
  269.                 for (int k = 0; k < 48; k++) { 
  270.                     k16[k] = kn[k]; 
  271.                 } 
  272.                 break; 
  273.             } 
  274.         } 
  275.     }