Go语言视频零基础入门到精通

javalearner

置换密码算法的原理是不改变明文字符，只将字符在明文中的排列顺序改变，从而实现明文信息的加密。置换密码有时又称为换位密码。  
              矩阵换位法是实现置换密码的一种常用方法。它将明文中的字母按照给的顺序安排在一个矩阵中，然后用根据密钥提供的顺序重新组合矩阵中字母，从而形成密文。例如，明文为attack begins at five，密钥为cipher，将明文按照每行6列的形式排在矩阵中，形成如下形式：  
              a t t a c k  
            b e g i n s  
            a t f i v e  
             根据密钥cipher中各字母在字母表中出现的先后顺序，给定一个置换：  
             1 2 3 4 5 6  
            f =  
            1 4 5 3 2 6  
            根据上面的置换，将原有矩阵中的字母按照第1列，第4列，第5列，第3列，第2列，第6列的顺序排列，则有下面形式：  
             a a c t t k  
            b i n g e s  
            a i v f t e  
             从而得到密文：aacttkbingesaivfte
            
   
      
      
      
   

1. [/code]
2.    
3.      package cn.hdu.edu.encrypt;  
4.       
5.       
6.      /*  
7.       * 古典密码算法之  置换算法  
8.       * @author ni掌柜  
9.       */
10.      public class Change {  
11.          //当加密或者解密成功时返回CRYPT_OK，失败时返回CRYPT_ERROR  
12.          private final static int CRYPT_OK =     1;   
13.          private final static int CRYPT_ERROR = 0;  
14.          /*  
15.           * @param initCode 没有加密前的字符串  
16.           * @CRYPT_OK 加密成功  
17.           * @CRYPT_ERROR 加密失败  
18.           */
19.          public static int encrypt(String initCode)throws Exception{  
20.          //用来输出加密后的字符      
21.          StringBuilder sb = new StringBuilder();  
22.            
23.          //获取initCode的字符串长度  
24.          int codeLength = initCode.length();  
25.          //根据这个codeLength来确定要几行6列  
26.          int rows = (int)Math.ceil(codeLength/6.0 );  
27.            
28.          //构造一个rows行6列的数组  
29.          char[][] initChar = new char[rows][6];  
30.          //存放initCode中的所有字符，包括空格  
31.          for(int i = 0; i < initChar.length; i++ )  
32.              for(int j=0; j < initChar[0].length; j++){  
33.                  //将对应字符放入这个数组中  
34.                  try{  
35.                      initChar[i][j] = initCode.charAt(  
36.                              (i ) * initChar[0].length + j  
37.                           );  
38.                  }catch(Exception e){  
39.                      //多出来的用@表示  
40.                      initChar[i][j] = 64;  
41.                  }  
42.              }  
43.          //进行如下转换  
44.          /*  
45.           * 00 01 02 03 04 05   
46.           * 10  11 12  13 14  15   
47.           */
48.           // 1 4 5 3 2 6  
49.            
50.          //构造一个rows行6列的数组 作为目标  
51.          char[][] targetChar = new char[rows][6];  
52.          for(int i = 0; i < targetChar.length; i++ )  
53.              for(int j=0; j < targetChar[0].length; j++){  
54.                  //第二列的字符是initChar中的第四列的字符  
55.                  if(j == 1 ){  
56.                      targetChar[i][j] = initChar[i][3];  
57.                  }  
58.                  //第三列的字符是initChar中的第五列的字符  
59.                  else if(j == 2){  
60.                      targetChar[i][j] = initChar[i][4];  
61.                  }  
62.                  //第四列的字符是initChar中的第三列的字符  
63.                  else if(j == 3){  
64.                      targetChar[i][j] = initChar[i][2];  
65.                  }  
66.                  //第五列的字符是initChar中的第二列的字符  
67.                  else if(j == 4){  
68.                      targetChar[i][j] = initChar[i][1];  
69.                  }  
70.                  //第一和六列的字符不变  
71.                  else{  
72.                      targetChar[i][j] = initChar[i][j];  
73.                  }  
74.              }  
75.          //整合成一个密文  
76.          //==================输出======================  
77.          for(int i = 0; i < targetChar.length; i++ )  
78.              for(int j=0; j < targetChar[0].length; j++){  
79.                  sb.append(targetChar[i][j] );  
80.              }  
81.      //  ==================输出======================  
82.      //  for(int i = 0; i < initChar.length; i++ )  
83.      //      for(int j=0; j < initChar[0].length; j++){  
84.      //          System.out.print(targetChar[i][j] );  
85.      //      }  
86.          //以下就是加密后的字符  
87.          String targetCode = sb.toString();  
88.          System.out.println(targetCode);  
89.              return CRYPT_OK;  
90.          }  
91.            
92.            
93.            
94.            
95.            
96.            
97.            
98.            
99.          /*  
100.           * @param targetCode 加密后的字符串  
101.           * @CRYPT_OK 解密成功  
102.           * @CRYPT_ERROR 解密失败  
103.           */
104.          public static int decrypt(String targetCode)throws Exception{  
105.            
106.              //用来输出解密后的字符      
107.          StringBuilder sb = new StringBuilder();  
108.            
109.          //获取targetCode的字符串长度  
110.          int codeLength = targetCode.length();  
111.          //根据这个codeLength来确定要几行6列  
112.          int rows = (int)Math.ceil(codeLength/6.0 );  
113.            
114.          //构造一个rows行6列的数组  
115.          char[][] targetChar = new char[rows][6];  
116.          //存放targetCode中的所有字符，包括空格  
117.          for(int i = 0; i < targetChar.length; i++ )  
118.              for(int j=0; j < targetChar[0].length; j++){  
119.                  //将对应字符放入这个数组中  
120.                      targetChar[i][j] = targetCode.charAt(  
121.                              (i ) * targetChar[0].length + j  
122.                           );  
123.              }  
124.            
125.          //由于加密的时候是如下变换，现在要变回来  
126.          /*  
127.           * 00 01 02 03 04 05   
128.           * 10  11 12  13 14  15   
129.           */
130.           // 1 4 5 3 2 6  
131.            
132.          //构造一个rows行6列的数组 作为目标  
133.          char[][] initChar = new char[rows][6];  
134.          for(int i = 0; i < initChar.length; i++ )  
135.              for(int j=0; j < initChar[0].length; j++){  
136.                  //init第二列的字符是targetChar中的第四列的字符  
137.                  if(j == 1 ){  
138.                      initChar[i][j] = targetChar[i][3];  
139.                  }  
140.                  //第三列的字符是targetChar中的第五列的字符  
141.                  else if(j == 2){  
142.                      initChar[i][j] = targetChar[i][4];  
143.                  }  
144.                  //第四列的字符是targetChar中的第三列的字符  
145.                  else if(j == 3){  
146.                      initChar[i][j] = targetChar[i][2];  
147.                  }  
148.                  //第五列的字符是targetChar中的第二列的字符  
149.                  else if(j == 4){  
150.                      initChar[i][j] = targetChar[i][1];  
151.                  }  
152.                  //第一和六列的字符不变  
153.                  else{  
154.                      initChar[i][j] = targetChar[i][j];  
155.                  }  
156.              }  
157.                
158.       
159.          //整合成一个密文  
160.          //==================输出======================  
161.          for(int i = 0; i < initChar.length; i++ )  
162.              for(int j=0; j < initChar[0].length; j++){  
163.                  sb.append(initChar[i][j] );  
164.              }  
165.       
166.      //  ==================输出======================  
167.      //  for(int i = 0; i < initChar.length; i++ )  
168.      //      for(int j=0; j < initChar[0].length; j++){  
169.      //          System.out.print(targetChar[i][j] );  
170.      //      }  
171.            
172.            
173.          //以下就是init的字符  
174.          String initCode = sb.toString();  
175.          System.out.println(initCode);  
176.              return CRYPT_OK;  
177.          }  
178.            
179.            
180.      }  
181.       
182.     [url=http://nileader.blog.51cto.com/1381108/298240]本文出自 51CTO.COM技术博客[/url]
183.     [code]

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/11/9/000426421.zip