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

javalearner

1. 来源：http://blog.csdn.net/zyg158/archive/2007/06/26/1667531.aspx
   
2.                         
3. public class IDEA {
   
4.     private byte[] Encrypt(byte[] bytekey, byte[] inputBytes, boolean flag) {
   
5.         byte[] encryptCode = new byte[8];
   
6.         // 分解子密钥
   
7.         int[] key = get_subkey(flag, bytekey);
   
8.         // 进行加密操作
   
9.         encrypt(key, inputBytes, encryptCode);
   
10.         // 返回加密数据
    
11.         return encryptCode;
    
12.     }
13. 
    
14.     private int bytesToInt(byte[] inBytes, int startPos) {
    
15.         return ((inBytes[startPos] << 8) & 0xff00) +
    
16.         (inBytes[startPos + 1] & 0xff);
    
17.     }
    
19. 
    
20.     private void intToBytes(int inputInt, byte[] outBytes, int startPos) {
    
21.         outBytes[startPos] = (byte) (inputInt >>> 8);
    
22.         outBytes[startPos + 1] = (byte) inputInt;
    
23.     }
    
25. 
    
26.     private int x_multiply_y(int x, int y) {
    
27.         if (x == 0) {
    
28.             x = 0x10001 - y;
    
29.         } else if (y == 0) {
    
30.             x = 0x10001 - x;
    
31.         } else {
    
32.             int tmp = x * y;
    
33.             y = tmp & 0xffff;
    
34.             x = tmp >>> 16;
    
35.             x = (y - x) + ((y < x) ? 1 : 0);
    
36.         }
    
37.         return x & 0xffff;
    
38.     }
39. 
    
40.     private void encrypt(int[] key, byte[] inbytes, byte[] outbytes) {
    
41.         int k = 0;
    
42.         int a = bytesToInt(inbytes, 0);
    
43.         int b = bytesToInt(inbytes, 2);
    
44.         int c = bytesToInt(inbytes, 4);
    
45.         int d = bytesToInt(inbytes, 6);
    
46.         for (int i = 0; i < 8; i++) {
    
47.             a = x_multiply_y(a, key[k++]);
    
48.             b += key[k++];
    
49.             b &= 0xffff;
    
50.             c += key[k++];
    
51.             c &= 0xffff;
    
52.             d = x_multiply_y(d, key[k++]);
    
53.             int tmp1 = b;
    
54.             int tmp2 = c;
    
55.             c ^= a;
    
56.             b ^= d;
    
57.             c = x_multiply_y(c, key[k++]);
    
58.             b += c;
    
59.             b &= 0xffff;
    
60.             b = x_multiply_y(b, key[k++]);
    
61.             c += b;
    
62.             c &= 0xffff;
    
63.             a ^= b;
    
64.             d ^= c;
    
65.             b ^= tmp2;
    
66.             c ^= tmp1;
    
67.         }
    
68.         intToBytes(x_multiply_y(a, key[k++]), outbytes, 0);
    
69.         intToBytes(c + key[k++], outbytes, 2);
    
70.         intToBytes(b + key[k++], outbytes, 4);
    
71.         intToBytes(x_multiply_y(d, key[k]), outbytes, 6);
    
72.     }
    
74. 
    
75.     private int[] encrypt_subkey(byte[] byteKey) {
    
76.         int[] key = new int[52];
    
77.         if (byteKey.length < 16) {
    
78.             byte[] tmpkey = new byte[16];
    
79.             System.arraycopy(byteKey, 0, tmpkey,
    
80.                 tmpkey.length - byteKey.length, byteKey.length);
    
81.             byteKey = tmpkey;
    
82.         }
    
83.         for (int i = 0; i < 8; i++) {
    
84.             key[i] = bytesToInt(byteKey, i * 2);
    
85.         }
    
86.         for (int j = 8; j < 52; j++) {
    
87.             if ((j & 0x7) < 6) {
    
88.                 key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 6] >> 7)) &
    
89.                     0xffff;
    
90.             } else if ((j & 0x7) == 6) {
    
91.                 key[j] = (((key[j - 7] & 0x7f) << 9) | (key[j - 14] >> 7)) &
    
92.                     0xffff;
    
93.             } else {
    
94.                 key[j] = (((key[j - 15] & 0x7f) << 9) | (key[j - 14] >> 7)) &
    
95.                     0xffff;
    
96.             }
    
97.         }
    
98.         return key;
    
99.     }
    
101. 
     
102.     private int fun_a(int a) {
     
103.         if (a < 2) {
     
104.             return a;
     
105.         }
     
106.         int b = 1;
     
107.         int c = 0x10001 / a;
     
108.         for (int i = 0x10001 % a; i != 1;) {
     
109.             int d = a / i;
     
110.             a %= i;
     
111.             b = (b + (c * d)) & 0xffff;
     
112.             if (a == 1) {
     
113.                 return b;
     
114.             }
     
115.             d = i / a;
     
116.             i %= a;
     
117.             c = (c + (b * d)) & 0xffff;
     
118.         }
     
119.         return (1 - c) & 0xffff;
     
120.     }
     
121.     private int fun_b(int b) {
     
122.         return (0 - b) & 0xffff;
     
123.     }
     
124.     private int[] uncrypt_subkey(int[] key) {
     
125.         int dec = 52;
     
126.         int asc = 0;
     
127.         int[] unkey = new int[52];
     
128.         int aa = fun_a(key[asc++]);
     
129.         int bb = fun_b(key[asc++]);
     
130.         int cc = fun_b(key[asc++]);
     
131.         int dd = fun_a(key[asc++]);
     
132.         unkey[--dec] = dd;
     
133.         unkey[--dec] = cc;
     
134.         unkey[--dec] = bb;
     
135.         unkey[--dec] = aa;
     
136.         for (int k1 = 1; k1 < 8; k1++) {
     
137.             aa = key[asc++];
     
138.             bb = key[asc++];
     
139.             unkey[--dec] = bb;
     
140.             unkey[--dec] = aa;
     
141.             aa = fun_a(key[asc++]);
     
142.             bb = fun_b(key[asc++]);
     
143.             cc = fun_b(key[asc++]);
     
144.             dd = fun_a(key[asc++]);
     
145.             unkey[--dec] = dd;
     
146.             unkey[--dec] = bb;
     
147.             unkey[--dec] = cc;
     
148.             unkey[--dec] = aa;
     
149.         }
     
150.         aa = key[asc++];
     
151.         bb = key[asc++];
     
152.         unkey[--dec] = bb;
     
153.         unkey[--dec] = aa;
     
154.         aa = fun_a(key[asc++]);
     
155.         bb = fun_b(key[asc++]);
     
156.         cc = fun_b(key[asc++]);
     
157.         dd = fun_a(key[asc]);
     
158.         unkey[--dec] = dd;
     
159.         unkey[--dec] = cc;
     
160.         unkey[--dec] = bb;
     
161.         unkey[--dec] = aa;
     
162.         return unkey;
     
163.     }
     
164.     private int[] get_subkey(boolean flag, byte[] bytekey) {
     
165.         if (flag) {
     
166.             return encrypt_subkey(bytekey);
     
167.         } else {
     
168.             return uncrypt_subkey(encrypt_subkey(bytekey));
     
169.         }
     
170.     }
     
171.     private byte[] ByteDataFormat(byte[] data, int unit) {
     
172.         int len = data.length;
     
173.         int padlen = unit - (len % unit);
     
174.         int newlen = len + padlen;
     
175.         byte[] newdata = new byte[newlen];
     
176.         System.arraycopy(data, 0, newdata, 0, len);
     
177.         for (int i = len; i < newlen; i++)
     
178.             newdata[i] = (byte) padlen;
     
179.         return newdata;
     
180.     }
     
181.     public byte[] IdeaEncrypt(byte[] idea_key, byte[] idea_data, boolean flag) {
     
182.         byte[] format_key = ByteDataFormat(idea_key, 16);
     
183.         byte[] format_data = ByteDataFormat(idea_data, 8);
     
184.         int datalen = format_data.length;
     
185.         int unitcount = datalen / 8;
     
186.         byte[] result_data = new byte[datalen];
     
187.         for (int i = 0; i < unitcount; i++) {
     
188.             byte[] tmpkey = new byte[16];
     
189.             byte[] tmpdata = new byte[8];
     
190.             System.arraycopy(format_key, 0, tmpkey, 0, 16);
     
191.             System.arraycopy(format_data, i * 8, tmpdata, 0, 8);
     
192.             byte[] tmpresult = Encrypt(tmpkey, tmpdata, flag);
     
193.             System.arraycopy(tmpresult, 0, result_data, i * 8, 8);
     
194.         }
     
195.         return result_data;
     
196.     }
     
197.     public static void main(String[] args) {
     
198.         String key = "0000000000000000";
     
199.         String data = "11111111";
     
200.         byte[] bytekey = key.getBytes();
     
201.         byte[] bytedata = data.getBytes();
     
202.         IDEA idea = new IDEA();
     
203.         byte[] encryptdata = idea.IdeaEncrypt(bytekey, bytedata, true);
     
204.         byte[] decryptdata = idea.IdeaEncrypt(bytekey, encryptdata, false);
     
205.         System.out.println("--------------------------------");
     
206.         for (int i = 0; i < bytedata.length; i++) {
     
207.             System.out.print(" " + bytedata[i] + " ");
     
208.         }
     
209.         System.out.println();
     
210.         System.out.println("-----------------------------------");
     
211.         for (int i = 0; i < encryptdata.length; i++) {
     
212.             System.out.print(" " + encryptdata[i] + " ");
     
213.         }
     
214.         System.out.println();
     
215.         System.out.println("-------------------------------");
     
216.         for (int i = 0; i < decryptdata.length; i++) {
     
217.             System.out.print(" " + decryptdata[i] + " ");
     
218.         }
     
219.         System.out.println("");
     
220.         System.out.println("--------------------------------");
     
221.     }
     
222. }
223. 
     
224. 运行结果：
225. 
     
226. C:        est>java    IDEA
227. -------------------------------------------------------------------------
228. 49  49  49  49  49  49  49  49
229. ----------------------------------------------------------------------------------
230. 72  -105  45  2  -44  -122  122  21  32  9  89  -75  19  28  -62  88
231. ------------------------------------------------------------------------------------------------
232. 49  49  49  49  49  49  49  49  8  8  8  8  8  8  8  8  -83  -31  -57  -13  24  -31  -113  25
233. ----------------------------------------------------------------------------------------------------------
     
234.                      

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/11/6/000323234.zip