Android加密策略

我们做项目的时候经常使用到加密算法，我了解的常用的加密算法有对称加密和非对称两大类型，对称加密

就是加密和解密使用同一个密钥，比如说大家广为使用的DES加密算法；非对称加密反之就是加密和解密使用不同

的密钥，一个“公钥”一个“私钥”，它们必须配对使用，否则不能打开文件，当然公钥是对外公布的，私钥不能对外公

布，只能由持有人自己知道，他的优越性就在这，因为对称式的加密方法如果在网络上传输加密文件就很难不把密

钥告诉对方，不管用什么方法都有可能被别窃听到。而非对称式的加密方法有2个密钥，公钥公开不怕别人知道，解

密时用私钥即可，很好的避免了密钥的传输安全性问题，比如当前使用费对称加密的HTTPS。

常常听小伙伴们提起MD5：

        MD5算法严格来说，并不能算是一种加密算法，只能说是一种摘要算法(数据摘要算法是密码学算法中灰常重要

的一个分支，它通过对所有数据提取指纹信息以实现数据签名、数据完整性校验等功能，由于其不可逆性，有时会被

用作敏感信息的加密。数据摘要算法也被称为哈希算法和散列算法)。它主要以512位分组来处理输入信息，且每一分

组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四哥32位分组组成，将这四个32位分组级联

后将生成一个128位散列值。    那么我们在开发中一般使用MD5来签名用户和密码。

了解SHA：

       安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

----摘自百度百科

SHA1java实现源码

[java]  view plain  copy

 print ?

1. public class SHA1Util {  
2.      private static final boolean hexcase = false;  
3.      private static final String b64pad = "=";  
4.      private static final int chrsz = 8;  
5.      // 得到字符串SHA-1值的方法  
6.     public static String hex_sha1(String s) {  
7.          s = (s == null) ? "" : s;  
8.          return binb2hex(core_sha1(str2binb(s), s.length() * chrsz));  
9.      }  
10.      public static String b64_hmac_sha1(String key, String data) {  
11.          return binb2b64(core_hmac_sha1(key, data));  
12.      }  
13.      public static String b64_sha1(String s) {  
14.          s = (s == null) ? "" : s;  
15.          return binb2b64(core_sha1(str2binb(s), s.length() * chrsz));  
16.      }  
17.      private static String binb2b64(int[] binarray) {  
18.          String tab = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789+/";  
19.          String str = "";  
20.          binarray = strechbinarray(binarray, binarray.length * 4);  
21.          for (int i = 0; i < binarray.length * 4; i += 3) {  
22.              int triplet = (((binarray[i >> 2] >> 8 * (3 - i % 4)) & 0xff) << 16)  
23.                      | (((binarray[i + 1 >> 2] >> 8 * (3 - (i + 1) % 4)) & 0xff) << 8)  
24.                      | ((binarray[i + 2 >> 2] >> 8 * (3 - (i + 2) % 4)) & 0xff);  
25.              for (int j = 0; j < 4; j++) {  
26.                  if (i * 8 + j * 6 > binarray.length * 32) {  
27.                      str += b64pad;  
28.                  } else {  
29.                      str += tab.charAt((triplet >> 6 * (3 - j)) & 0x3f);  
30.                  }  
31.              }  
32.          }  
33.          return cleanb64str(str);  
34.      }  
35.      private static String binb2hex(int[] binarray) {  
36.          String hex_tab = hexcase ? "0123456789abcdef" : "0123456789abcdef";  
37.          String str = "";  
38.          for (int i = 0; i < binarray.length * 4; i++) {  
39.              char a = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8 + 4)) & 0xf);  
40.              char b = (char) hex_tab.charAt((binarray[i >> 2] >> ((3 - i % 4) * 8)) & 0xf);  
41.              str += (new Character(a).toString() + new Character(b).toString());  
42.          }  
43.          return str;  
44.      }  
45.      private static String binb2str(int[] bin) {  
46.          String str = "";  
47.          int mask = (1 << chrsz) - 1;  
48.          for (int i = 0; i < bin.length * 32; i += chrsz) {  
49.              str += (char) ((bin[i >> 5] >>> (24 - i % 32)) & mask);  
50.          }  
51.          return str;  
52.      }  
53.      private static int bit_rol(int num, int cnt) {  
54.          return (num << cnt) | (num >>> (32 - cnt));  
55.      }  
56.      private static String cleanb64str(String str) {  
57.          str = (str == null) ? "" : str;  
58.          int len = str.length();  
59.          if (len <= 1) {  
60.              return str;  
61.          }  
62.          char trailchar = str.charAt(len - 1);  
63.          String trailstr = "";  
64.          for (int i = len - 1; i >= 0 && str.charAt(i) == trailchar; i--) {  
65.              trailstr += str.charAt(i);  
66.          }  
67.          return str.substring(0, str.indexOf(trailstr));  
68.      }  
69.      private static int[] complete216(int[] oldbin) {  
70.          if (oldbin.length >= 16) {  
71.              return oldbin;  
72.          }  
73.          int[] newbin = new int[16 - oldbin.length];  
74.          for (int i = 0; i < newbin.length; newbin[i] = 0, i++)  
75.              ;  
76.          return concat(oldbin, newbin);  
77.      }  
78.      private static int[] concat(int[] oldbin, int[] newbin) {  
79.          int[] retval = new int[oldbin.length + newbin.length];  
80.          for (int i = 0; i < (oldbin.length + newbin.length); i++) {  
81.              if (i < oldbin.length) {  
82.                  retval[i] = oldbin[i];  
83.              } else {  
84.                  retval[i] = newbin[i - oldbin.length];  
85.              }  
86.          }  
87.          return retval;  
88.      }  
89.      private static int[] core_hmac_sha1(String key, String data) {  
90.          key = (key == null) ? "" : key;  
91.          data = (data == null) ? "" : data;  
92.          int[] bkey = complete216(str2binb(key));  
93.          if (bkey.length > 16) {  
94.              bkey = core_sha1(bkey, key.length() * chrsz);  
95.          }  
96.          int[] ipad = new int[16];  
97.          int[] opad = new int[16];  
98.          for (int i = 0; i < 16; ipad[i] = 0, opad[i] = 0, i++)  
99.              ;  
100.          for (int i = 0; i < 16; i++) {  
101.              ipad[i] = bkey[i] ^ 0x36363636;  
102.              opad[i] = bkey[i] ^ 0x5c5c5c5c;  
103.          }  
104.          int[] hash = core_sha1(concat(ipad, str2binb(data)), 512 + data.length() * chrsz);  
105.          return core_sha1(concat(opad, hash), 512 + 160);  
106.      }  
107.      private static int[] core_sha1(int[] x, int len) {  
108.          int size = (len >> 5);  
109.          x = strechbinarray(x, size);  
110.          x[len >> 5] |= 0x80 << (24 - len % 32);  
111.          size = ((len + 64 >> 9) << 4) + 15;  
112.          x = strechbinarray(x, size);  
113.          x[((len + 64 >> 9) << 4) + 15] = len;  
114.          int[] w = new int[80];  
115.          int a = 1732584193;  
116.          int b = -271733879;  
117.          int c = -1732584194;  
118.          int d = 271733878;  
119.          int e = -1009589776;  
120.          for (int i = 0; i < x.length; i += 16) {  
121.              int olda = a;  
122.              int oldb = b;  
123.              int oldc = c;  
124.              int oldd = d;  
125.              int olde = e;  
126.              for (int j = 0; j < 80; j++) {  
127.                  if (j < 16) {  
128.                      w[j] = x[i + j];  
129.                  } else {  
130.                      w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);  
131.                  }  
132.                  int t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), safe_add(safe_add(e, w[j]), sha1_kt(j)));  
133.                  e = d;  
134.                  d = c;  
135.                  c = rol(b, 30);  
136.                  b = a;  
137.                  a = t;  
138.              }  
139.              a = safe_add(a, olda);  
140.              b = safe_add(b, oldb);  
141.              c = safe_add(c, oldc);  
142.              d = safe_add(d, oldd);  
143.              e = safe_add(e, olde);  
144.          }  
145.          int[] retval = new int[5];  
146.          retval[0] = a;  
147.          retval[1] = b;  
148.          retval[2] = c;  
149.          retval[3] = d;  
150.          retval[4] = e;  
151.          return retval;  
152.      }  
153.      private static void dotest() {  
154.          String key = "key";  
155.          String data = "data";  
156.          System.out.println("hex_sha1(" + data + ")=" + hex_sha1(data));  
157.          System.out.println("b64_sha1(" + data + ")=" + b64_sha1(data));  
158.          System.out.println("str_sha1(" + data + ")=" + str_sha1(data));  
159.          System.out.println("hex_hmac_sha1(" + key + "," + data + ")=" + hex_hmac_sha1(key, data));  
160.          System.out.println("b64_hmac_sha1(" + key + "," + data + ")=" + b64_hmac_sha1(key, data));  
161.          System.out.println("str_hmac_sha1(" + key + "," + data + ")=" + str_hmac_sha1(key, data));  
162.      }  
163.      public static String hex_hmac_sha1(String key, String data) {  
164.          return binb2hex(core_hmac_sha1(key, data));  
165.      }  
166.      private static int rol(int num, int cnt) {  
167.          return (num << cnt) | (num >>> (32 - cnt));  
168.      }  
169.      private static int safe_add(int x, int y) {  
170.          int lsw = (int) (x & 0xffff) + (int) (y & 0xffff);  
171.          int msw = (x >> 16) + (y >> 16) + (lsw >> 16);  
172.          return (msw << 16) | (lsw & 0xffff);  
173.      }  
174.      private static int sha1_ft(int t, int b, int c, int d) {  
175.          if (t < 20)  
176.              return (b & c) | ((~b) & d);  
177.          if (t < 40)  
178.              return b ^ c ^ d;  
179.          if (t < 60)  
180.              return (b & c) | (b & d) | (c & d);  
181.          return b ^ c ^ d;  
182.      }  
183.      private static int sha1_kt(int t) {  
184.          return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : (t < 60) ? -1894007588 : -899497514;  
185.      }  
186.      private static boolean sha1_vm_test() {  
187.          return hexcase ? hex_sha1("abc").equals("a9993e364706816aba3e25717850c26c9cd0d89d") : hex_sha1("abc").equals(  
188.                  "a9993e364706816aba3e25717850c26c9cd0d89d");  
189.      }  
190.      public static String str_hmac_sha1(String key, String data) {  
191.          return binb2str(core_hmac_sha1(key, data));  
192.      }  
193.      public static String str_sha1(String s) {  
194.          s = (s == null) ? "" : s;  
195.          return binb2str(core_sha1(str2binb(s), s.length() * chrsz));  
196.      }  
197.      private static int[] str2binb(String str) {  
198.          str = (str == null) ? "" : str;  
199.          int[] tmp = new int[str.length() * chrsz];  
200.          int mask = (1 << chrsz) - 1;  
201.          for (int i = 0; i < str.length() * chrsz; i += chrsz) {  
202.              tmp[i >> 5] |= ((int) (str.charAt(i / chrsz)) & mask) << (24 - i % 32);  
203.          }  
204.          int len = 0;  
205.          for (int i = 0; i < tmp.length && tmp[i] != 0; i++, len++)  
206.              ;  
207.          int[] bin = new int[len];  
208.          for (int i = 0; i < len; i++) {  
209.              bin[i] = tmp[i];  
210.          }  
211.          return bin;  
212.      }  
213.      private static int[] strechbinarray(int[] oldbin, int size) {  
214.          int currlen = oldbin.length;  
215.          if (currlen >= size + 1) {  
216.              return oldbin;  
217.          }  
218.          int[] newbin = new int[size + 1];  
219.          for (int i = 0; i < size; newbin[i] = 0, i++)  
220.              ;  
221.          for (int i = 0; i < currlen; i++) {  
222.              newbin[i] = oldbin[i];  
223.          }  
224.          return newbin;  
225.      }  
226.      public static void main(String args[]) {  
227.          System.out.println("admin的SHA1的值为：" + hex_sha1("admin") + ",length=" + hex_sha1("admin").length());  
228.      }  
229.  }  

了解AES：

高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。

                                                         ----摘自百度百科

详细参考aes

了解DES：

DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。需要注意的是，在某些文献中，作为算法的DES称为数据加密算法（Data Encryption Algorithm,DSA），已与作为标准的DES区分开来。

----摘自百度百科

算法说明:

DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位（实际用到了56位，第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1），其算法主要分为两步：

1）初始置换

其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位,其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位,R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。

其置换规则见下表：

58,50,42,34,26,18,10,2,60,52,44,36,28,20,12,4,

62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,

57,49,41,33,25,17,9,1,59,51,43,35,27,19,11,3,

61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,

2）逆置换

经过16次迭代运算后,得到L16、R16,将此作为输入,进行逆置换,逆置换正好是初始置换的逆运算，由此即得到密文输出。

此算法是 对称加密算法体系中的代表,在计算机网络系统中广泛使用.

了解RSA：

RSA 公钥 加密算法是1977年由 罗纳德·李维斯特（Ron Rivest）、 阿迪·萨莫尔（Adi Shamir）和 伦纳德·阿德曼（Leonard Adleman）一起提出的。1987年首次公布，当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥 数据加密标准。

今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。但在 分布式计算和 量子计算机理论日趋成熟的今天，RSA加密安全性受到了挑战。

RSA算法基于一个十分简单的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

附上实现细节: 实现细节

了解BASE64：

Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base64来将一个较长的唯一标识符（一般为128-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base64编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。

编码规则:

①.把3个字符变成4个字符。

②每76个字符加一个换行符。

③.最后的结束符也要处理。

举例说明:

转换前 10101101,10111010,01110110

转换后 00101011, 00011011 ,00101001 ,00110110

十进制 43 27 41 54

对应码表中的值 r b p 2

所以上面的24位编码，编码后的Base64值为 rbp2

解码同理，把 rbq2 的二进制位连接上再重组得到三个8位值，得出原码。

（解码只是编码的逆过程，有关MIME的RFC还有很多，如果需要详细情况请自行查找。）

第一个字节，根据源字节的第一个字节处理。

规则：源第一字节右移两位，去掉低2位，高2位补零。

既：00 + 高6位

第二个字节，根据源字节的第一个字节和第二个字节联合处理。

规则如下，第一个字节高6位去掉然后左移四位，第二个字节右移四位

即：源第一字节低2位 + 源第2字节高4位

第三个字节，根据源字节的第二个字节和第三个字节联合处理，

规则第二个字节去掉高4位并左移两位（得高6位），第三个字节右移6位并去掉高6位（得低2位），相加即可

第四个字节，规则，源第三字节去掉高2位即可

//用更接近于编程的思维来说，编码的过程是这样的：

//第一个字符通过右移2位获得第一个目标字符的Base64表位置，根据这个数值取到表上相应的字符，就是第一//个目标字符。

//然后将第一个字符与0x03(00000011)进行与(&)操作并左移4位,接着第二个字符右移4位与前者相或(|)，即获得第二个目标字符。

//再将第二个字符与0x0f(00001111)进行与(&)操作并左移2位,接着第三个字符右移6位与前者相或(|)，获得第三个目标字符。

//最后将第三个字符与0x3f(00111111)进行与(&)操作即获得第四个目标字符。

//在以上的每一个步骤之后，再把结果与 0x3F 进行 AND  位操作，就可以得到编码后的字符了。

可是等等……聪明的你可能会问到，原文的字节数量应该是3的倍数啊，如果这个条件不能满足的话，那该怎么办呢？

我们的解决办法是这样的：原文剩余的字节根据编码规则继续单独转(1变2,2变3;不够的位数用0补全)，再用=号补满4个字节。这就是为什么有些Base64编码会以一个或两个等号结束的原因，但等号最多只有两个。因为：

一个原字节至少会变成两个目标字节

所以余数任何情况下都只可能是0，1，2这三个数中的一个。如果余数是0的话，就表示原文字节数正好是3的倍数（最理想的情况）。如果是1的话，转成2个Base64编码字符，为了让Base64编码是4的倍数，就要补2个等号；同理，如果是2的话，就要补1个等号。

java实现源码：

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">//模板类模板类写好了再按思路写个实现就可以了  
2. publicinterfaceBase64{  
3. /** 
4. *根据传进来的字符的字节码，查询base64码表的索引，并返回所查到的索引 
5. * 
6. *@paramb一个编码后的字节码 
7. *@return返回base64码表的索引 
8. */  
9. publicabstractbytebaseIndex(byteb);  
10. /** 
11. *解码的方法 
12. *传进来的是编码后的base64字符的字节码 
13. *解析时是4个一组进行解析 
14. *@paramb编码后的字符的字节码数组 
15. *@return返回原来的字符串 
16. */  
17. publicabstractStringbackEncode(byte[]b);  
18. /** 
19. *解码 
20. *将4个字节码中的第1个的后6位（00xxxxxx）和第2个 
21. *字节的前4位的后2位（00yy0000） 
22. *还原为原来的字节码（xxxxxxyy） 
23. * 
24. *@paramfirst4个字节码中的第1个 
25. *@paramsecond4个字节码中的第2个 
26. *@return原来的字符的字节码 
27. */publicabstractbytebackFirst(bytefirst,bytesecond);  
28. /** 
29. *解码 
30. *将4个字节码中的第2个的后4位（0000xxxx）和第3个 
31. *字节的前6位的后4位（00yyyy00） 
32. *还原为原来的字节码（xxxxyyyy） 
33. *@paramsecond4个字节码中的第2个 
34. *@paramthird4个字节码中的第3个 
35. *@return原来的字符的字节码 
36. */  
37. publicabstractbytebackSecond(bytesecond,bytethird);  
38. /** 
39. *解码 
40. *将4个字节码中的第3个的后2位（000000xx）和第4个 
41. *字节的后6位（00yyyyyy） 
42. *还原为原来的字节码（xxyyyyyy） 
43. *@paramthird传进来的第3个字符 
44. *@paramfourth传进来的第4个字符 
45. *@return原来的字符的字节码 
46. */publicabstractbytebackThird(bytethird,bytefourth);  
47. /** 
48. *解码 
49. *将编码后的字符串数组的最后2个字节码还原为原来的字节码 
50. *假如数组末尾剩下2个字节： 
51. *将倒数第2个字节的前后6位(00xxxxxx) 
52. *和倒数第一个字节的后2位(000000yy) 
53. *还原为原来的编码（xxxxxxyy） 
54. *假如数组末尾剩下3个字节： 
55. *将倒数第2个字节的前后4位(0000xxxx) 
56. *和倒数第一个字节的后4位(0000yyyy) 
57. *还原为原来的编码（xxxxyyyy） 
58. *@paramlast_b倒数第2个字节 
59. *@paramnext_b倒数第1个字节 
60. *@parammove_l倒数第2个字节移动位数的参数 
61. *@parammove_b倒数第1个字节移动位数的参数 
62. *@return原来的字符的字节码 
63. */  
64. publicbytebackLastOne(bytelast_b,bytenext_b,intmove_l,intmove_b);  
65. /** 
66. *编码 
67. *将传进来的字符编码为base64，返回一个base64的字符串 
68. *编码时3个字节一组进行编码，传进来的是要进行编码的字符串数组 
69. *@paramb要进行编码的字符串数组 
70. *@return编码后的字符串 
71. */  
72. publicabstractStringencode(byte[]b);  
73. /** 
74. *假如字符长度%3！=0，使用此方法编码末尾字符 
75. *假如b=xxxxyyyy 
76. *假如末尾字节个数等于1： 
77. *将这个字节的前6位作为一个字节(00xxxxyy) 
78. *将这个字节的后6位作为一个字节(00xxyyyy) 
79. *假如末尾字节个数等于2： 
80. *将这个字节的后6位作为一个字节(00xxyyyy) 
81. *@paramb末尾的字符的字节码 
82. *@parammove末尾的字符的字节码要移动的位数的参数 
83. *@return编码后的字节码 
84. */  
85. publicabstractbytelastOneByte(byteb,intmove);  
86. /** 
87. *编码 
88. *假如b=xxxxyyyy 
89. *将第1个字节的前6位编码为base64 
90. *将3个字节中的第1个子节码转为（00xxxxyy） 
91. *@paramb3个字节中的第1个字节 
92. *@return编码后的字节码 
93. */  
94. publicabstractbytefirstByte(byteb);  
95. /** 
96. *编码 
97. *假如last_b=xxxxyyyynext_b=kkkkffff 
98. *将3个字节中的第1个字节的最后2位（000000yy） 
99. *和第2个字节的前4位（kkkk0000）编码为（00yykkkk） 
100. * 
101. *@paramlast_b3个字节中的第1个字节 
102. *@paramnext_b3个字节中的第2个字节 
103. *@return编码后的字节码 
104. */  
105. publicabstractbytesecondByte(bytelast_b,bytenext_b);  
106. /** 
107. *编码 
108. *假如last_b=xxxxyyyynext_b=kkkkffff 
109. *将3个字节中的第2个字节的最后4位（0000yyyy） 
110. *和第4个字节的前2位（kk000000）编码为（00yyyykk） 
111. * 
112. * 
113. *@paramlast_b3个字节中的第2个字节 
114. *@paramnext_b3个字节中的第3个字节 
115. *@return编码后的字节码 
116. */  
117. publicabstractbytethirdByte(bytelast_b,bytenext_b);  
118. /** 
119. *编码 
120. *假如b=xxxxyyyy 
121. *将3个字节中的第3个字节的最后6位（00xxyyyy） 
122. *转码为（00xxyyyy） 
123. *@paramb3个字节中的第3个字节 
124. *@return编码后的字节码 
125. */  
126. publicabstractbytefourthByte(byteb);  
127. }</span>  

======================以下是实现类代码=====================华丽的分界线======

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">importjava.util.Enumeration;  
2. importjava.util.Vector;  
3. publicclassMyBase64EncoderimplementsBase64{  
4. /** 
5. *base64码表 
6. */  
7. privatestaticfinalbytebase[]={0x41,0x42,0x43,0x44,0x45,0x46,  
8. 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,  
9. 0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,0x61,0x62,  
10. 0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,  
11. 0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,  
12. 0x79,0x7a,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,  
13. 0x39,0x2b,0x2f};</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytebaseIndex(byteb){  
3. for(inti=0;i<base.length;i++){  
4. if(base[i]==b){  
5. return(byte)i;  
6. }  
7. }  
8. return-1;  
9. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicStringbackEncode(byte[]b){  
3. StringBuffersb=newStringBuffer();  
4. Vector<Byte>list=newVector<Byte>();  
5. intreal_len=b.length;  
6. intlen=real_len-2;  
7. intmore_len=len&3;  
8. intuse_len=len-more_len;</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">for(inti=0;i<use_len;i+=4){  
2. list.add(backFirst(baseIndex(b[i]),baseIndex(b[i+1])));  
3. list.add(backSecond(baseIndex(b[i+1]),baseIndex(b[i+2])));  
4. list.add(backThird(baseIndex(b[i+2]),baseIndex(b[i+3])));  
5. }  
6. Enumeratione=list.elements();  
7. bytebytes[]=newbyte[list.size()];  
8. intk=-1;  
9. while(e.hasMoreElements()){  
10. bytes[++k]=(Byte)e.nextElement();  
11. }  
12. sb.append(newString(bytes));</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">if(more_len==2){  
2. byteb_1[]=newbyte[1];  
3. b_1[0]=backLastOne(baseIndex(b[len-2]),baseIndex(b[len-1]),2,6);  
4. sb.append(newString(b_1));  
5. }  
6. if(more_len==3){  
7. byteb_2[]=newbyte[2];  
8. b_2[0]=backFirst(baseIndex(b[len-3]),baseIndex(b[len-2]));  
9. b_2[1]=backLastOne(baseIndex(b[len-2]),baseIndex(b[len-1]),4,4);  
10. sb.append(newString(b_2));  
11. }  
12. returnsb.toString();  
13. }  
14. @Override  
15. publicbytelastOneByte(byteb,intmove){  
16. intr_b=b&0xff;  
17. r_b=r_b<<move;  
18. r_b=r_b>>>2;  
19. return(byte)(r_b&0x3f);  
20. }  
21. @Override  
22. publicbytebackLastOne(bytelast_b,bytenext_b,intmove_l,intmove_b){  
23. intr_l=last_b&0xff;  
24. intr_n=next_b&0xff;  
25. r_l=r_l<<move_l;  
26. r_n=r_n<<move_b;  
27. r_n=r_n>>>move_b;  
28. return(byte)((r_l|r_n)&0xff);  
29. }  
30. @Override  
31. publicbytebackFirst(bytefirst,bytesecond){  
32. intr_f=first&0xff;  
33. intr_s=second&0xff;  
34. r_f=r_f<<2;  
35. r_s=r_s>>>4;  
36. return(byte)((r_f|r_s)&0xff);  
37. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytebackSecond(bytesecond,bytethird){  
3. intr_s=second&0xff;  
4. intr_t=third&0xff;  
5. r_s=r_s<<4;  
6. r_t=r_t>>>2;  
7. return(byte)((r_s|r_t)&0xff);  
8. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytebackThird(bytethird,bytefourth){  
3. intr_t=third&0xff;  
4. intr_f=fourth&0xff;  
5. r_t=r_t<<6;  
6. return(byte)((r_t|r_f)&0xff);  
7. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicStringencode(byte[]b){  
3. StringBuffersb=newStringBuffer();  
4. intlen=b.length;  
5. intmore_len=len%3;  
6. intuse_len=len-more_len;  
7. byte[]bytes=newbyte[4];  
8. for(inti=0;i<use_len;i+=3){  
9. bytes[0]=base[firstByte(b[i])];  
10. bytes[1]=base[secondByte(b[i],b[i+1])];  
11. bytes[2]=base[thirdByte(b[i+1],b[i+2])];  
12. bytes[3]=base[fourthByte(b[i+2])];  
13. sb.append(newString(bytes));  
14. }  
15. if(more_len==1){  
16. byteb_2[]=newbyte[2];  
17. b_2[0]=base[firstByte(b[len-1])];  
18. b_2[1]=base[lastOneByte(b[len-1],6)];  
19. sb.append(newString(b_2));  
20. returnsb.append("==").toString();  
21. }elseif(more_len==2){  
22. byteb_3[]=newbyte[3];  
23. b_3[0]=base[firstByte(b[len-2])];  
24. b_3[1]=base[secondByte(b[len-2],b[len-1])];  
25. b_3[2]=base[lastOneByte(b[len-1],4)];  
26. sb.append(newString(b_3));  
27. returnsb.append("=").toString();  
28. }  
29. returnsb.toString();  
30. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytefirstByte(byteb){  
3. //00000000000000000000000001010011  
4. //01010011  
5. intr_f=b&0xff;  
6. r_f=r_f>>>2;  
7. return(byte)(r_f&0x3f);  
8. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytesecondByte(bytelast_b,bytenext_b){  
3. intr_l=last_b&0xff;  
4. intr_n=next_b&0xff;  
5. r_l=r_l<<6;  
6. r_l=r_l>>>2;  
7. r_n=r_n>>>4;  
8. return(byte)((r_l|r_n)&0x3f);  
9. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytethirdByte(bytelast_b,bytenext_b){  
3. intr_l=last_b&0xff;  
4. intr_n=next_b&0xff;  
5. r_l=r_l<<4;  
6. r_l=r_l>>>2;  
7. r_n=r_n>>>6;  
8. return(byte)((r_l|r_n)&0x3f);  
9. }</span>  

[java]  view plain  copy

 print ?

1. <span style="font-weight: normal;">@Override  
2. publicbytefourthByte(byteb){  
3. intr_b=b&0xff;  
4. r_b=r_b<<2;  
5. r_b=r_b>>>2;  
6. return(byte)(r_b&0x3f);  
7. }  
8. }</span>  

更多语言实现----- 点击打开链接

Android加密策略---结束语

加密就总结到这了，当然还有好多这里没有一一例举

3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高；

RC2和 RC4：用变长密钥对大量数据进行加密，比 DES 快；

IDEA（International Data Encryption Algorithm）国际数据加密算法：使用 128 位密钥提供非常强的安全性；