1 背景介绍
话说目前做所谓"企业"开发的语言基本就集中在运用.Net和J2EE上了。又话说，在下很不幸又和Java"同流合污"了一把。现在回想起来，真是感慨万千啊～遥想公瑾当年，小乔初嫁了，雄姿英发，羽扇纶巾，谈笑间，强虏灰飞烟灭。～
额，下面插播一下正题。其实，目前国内用Java做真正的"企业级"得其实并不是很多，绝大多数都是用个SSH1就觉得这就是Java之企业级开发了，之后就开始沾沾自喜了。这你说让Servlet和EJB3情何以堪啊～所以说，目前国内大多数Java的开发环境并不能说真正的武装到牙齿。
基于这样的原因，有些时候，我们在做一些"工程"的时候～，当然对于多数情况就是IDE菜单选择"新建工程"这么个选项出来的货了，对于某些应用，需要用到一些加密算法，虽说Java自身带有专门的加密库，但是那个用起来的确有些麻烦，而且加密算法还是动态加载的，在本地测试的话问题还不是很大，痛苦的是万一到服务器上一跑，这个加密算法加载失败什么的，这可就大条了。如果说是一个什么认证系统之类的，那也就罢了。但如果只是一些对密码强要求很低，但不加密又不行的情况，那的确是挺麻烦的一件事情。
那么，处于对易用性，易实现性的考虑，那些什么DES算法就暂时不考虑了。如果真有这个需求的话，相信找个健壮性很高的DES问题还不是很大的。而在那许多经典的加密算法中，要数Caesar加密比较经典了。所以，处于这样的一个需求，就打算实现一个经典加密算法。
2 Caesar加密算法
Caesar加密算法算是经典加密算法中最简单的了。对于标准的Caesar来说，就是把字母序列向后移动一定的数量，替换后得到密文，而这个数量为固定值3。也就是说，在都是由英文字母组成的文本里，字母A将会被替换成D，B会被替换成E，以此类推。
对于Caesar加密算法，存在几点问题。首先是这个作为密钥的值是个固定的3，而且字母表又是按顺序排列的，所以只要对方知道你是用Caesar加密的，就很容易的脱密成原文，虽然有些麻烦，但是这就和用原文是差不多的，即使对加密要求很低也不能低成这样不是？然后是这个替换表，因为是基于字母表的，所以对于英文来说只能加密英文字母，这样就不能被支持了。最后，因为替换是固定的，所以，对于同一个字母，加密后的字母也是固定的。比如"AAA"这个文本加密后，就是"DDD"，看起来还不够迷惑人。
基于以上的原因，我这里实现的Caesar做了一些修改，但是总的思路还是Caesar。
1. public class Caesar {
2. private String table;
3. private int seedA = 1103515245;
4. private int seedB = 12345;
5.
6. public Caesar(String table, int seed) {
7. this.table = chaos(table, seed, table.length());
8. }
9. public Caesar(String table) {
10. this(table, 11);
11. }
12. public Caesar() {
13. this(11);
14. }
15. public Caesar(int seed) {
16. this("ABCDEFGHIJKLMNOPQRSTUVWXYZ", seed);
17. }
18. public char dict(int i, boolean reverse) {
19. int s = table.length(), index = reverse ? s - i : i;
20. return table.charAt(index);
21. }
22. public int dict(char c, boolean reverse) {
23. int s = table.length(), index = table.indexOf(c);
24. return reverse ? s - index : index;
25. }
26. public int seed(int seed) {
27. long temp = seed;
28. return (int)((temp * seedA + seedB) & 0x7fffffffL);
29. }
30.
31. public String chaos(String data, int seed, int cnt) {
32. StringBuffer buf = new StringBuffer(data);
33. char tmp; int a, b, r = data.length();
34. for (int i = 0; i < cnt; i += 1) {
35. seed = seed(seed); a = seed % r;
36. seed = seed(seed); b = seed % r;
37. tmp = buf.charAt(a);
38. buf.setCharAt(a, buf.charAt(b));
39. buf.setCharAt(b, tmp);
40. }
41. return buf.toString();
42. }
43.
44. public String crypto(boolean reverse,
45. int key, String text) {
46. String ret = null;
47. StringBuilder buf = new StringBuilder();
48. int m, s = table.length(), e = text.length();
49.
50. for(int i = 0; i < e; i += 1) {
51. m = dict(text.charAt(i), reverse);
52. if (m < 0) break;
53. m = m + key + i;
54. buf.append(dict(m % s, reverse));
55. }
56. if (buf.length() == e)
57. ret = buf.toString();
58. return ret;
59. }
60. public String encode(int key, String text) {
61. return crypto(false, key, text);
62.
63. }
64. public String decode(int key, String text) {
65. return crypto(true , key, text);
66. }
67.
68. public static void main(String args) {
69. Caesar caesar = new Caesar();
70. String data = caesar.encode(32, "APPLE");
71. caesar.decode(32, data);
72. }
73. }
在上面的Caesar实现中，我用一个整数替代了原来作为密钥的固定值3。其次，可以通过传入不同的字符集让这个加密算法的适用性更广泛。最后，算法类在初始化的时候，会对替换表做一次扰乱操作，这样的话，即使是相同的替换表，因为初始化传入的seed不同，加密出来的内容也会不同。至于程序的细节，我想源码会更直观的告诉你的。
3 Vigenere加密算法
其实，Vigenere加密算法从历史考证来看好像并不是一个叫Vigenere的人发明的。大概只是因为某些机缘巧合，被一个叫Vigenere的人用了，并且流传开了，然后就被叫做Vigenere加密算法了。后来发现这原来是一个美丽的误解，但是既然都已经被叫习惯了，改口自然是很难了，因此就那么流传下来了。说道这里，Bellaso先生又一次的泪目了。
为什么我这里要把Vigenere密码和Caesar放在一起呢？因为Vigenere算是一个升级版的Caesar算法。所以，当时实现了那个Caesar后，就顺带连 Bellaso 和 Vigenere 先生，也一起缅怀一下了。和Caesar相比Vigenere是一个多表替代，就是说针对明文中不同位置的字母，会选用不同的替换表来加密。如果用上面的例子来说，对于不同位置的字母，会选择不同的key去加密。说白了，就是多个Caesar叠加起来就是Vigenere。
虽然说Vigenere在加密的效果上比Caesar有很多提升了，也弥补了Caesar上存在的一些问题。但是，我的实现还是做了一些小小的调整。
1. public class Vigenere {
2. private String table;
3. private int seedA = 1103515245;
4. private int seedB = 12345;
5.
6. public Vigenere(String table, int seed) {
7. this.table = chaos(table, seed, table.length());
8. }
9. public Vigenere(String table) {
10. this(table, 11);
11. }
12. public Vigenere() {
13. this(11);
14. }
15. public Vigenere(int seed) {
16. this("ABCDEFGHIJKLMNOPQRSTUVWXYZ", seed);
17. }
18.
19. private char dict(int i, boolean reverse) {
20. int s = table.length(), index = reverse ? s - i : i;
21. return table.charAt(index);
22. }
23. private int dict(char c, boolean reverse) {
24. int s = table.length(), index = table.indexOf(c);
25. return reverse ? s - index : index;
26. }
27. private int seed(int seed) {
28. long temp = seed;
29. return (int)((temp * seedA + seedB) & 0x7fffffffL);
30. }
31.
32. public String chaos(String data, int seed, int cnt) {
33. StringBuffer buf = new StringBuffer(data);
34. char tmp; int a, b, r = data.length();
35. for (int i = 0; i < cnt; i += 1) {
36. seed = seed(seed); a = seed % r;
37. seed = seed(seed); b = seed % r;
38. tmp = buf.charAt(a);
39. buf.setCharAt(a, buf.charAt(b));
40. buf.setCharAt(b, tmp);
41. }
42. return buf.toString();
43. }
44. public String crypto(boolean reverse,
45. String key, String text) {
46. String ret = null;
47. StringBuilder buf = new StringBuilder();
48. int m, k, s = table.length(),
49. e = text.length(),
50. ke = key.length();
51.
52. for(int i = 0; i < e; i += 1) {
53. m = dict(text.charAt(i), reverse);
54. k = dict(key.charAt(i % ke), false);
55. if (m < 0 || k < 0) break;
56. m = m + k + i;
57. buf.append(dict(m % s, reverse));
58. }
59. if (buf.length() == e)
60. ret = buf.toString();
61. return ret;
62. }
63. public String encode(String key, String text) {
64. return crypto(false, key, text);
65.
66. }
67. public String decode(String key, String text) {
68. return crypto(true , key, text);
69. }
70. public static void main(String args) {
71. Vigenere vigenere = new Vigenere();
72. String data = vigenere.encode("BELLASO", "APPLE");
73. vigenere.decode("BELLASO", data);
74. }
75. }
话说，Vigenere加密算法传入的密钥到不是一个数字，是一个字符串。这个字符串中所用的字符，必须在替换表中出现过的。总的来说，Vigenere的强度要比Caesar强一些。但是终究还是会被破解的。不过，Vigenere有机会成为强度相当高的一种加密手段，前提是～前提是你的密钥长度大于或等于明文长度。然而，在实际应用中，这个密钥总是小于明文长度的。
4 总结
总的来说，理解这两个加密算法都不算太难。对于密码学大牛来说，这简直是小儿科了。两个算法有许多地方都是公用的，只是在一些地方有少许不同。在开发中，可以根据自己的喜好选择一下。不要期待这两个加密算法能有多大的抗破解强度，但是，作为一个烟雾弹掩盖一下明文还是可以的。不过，如果你要将这个加密算法反复对一组明文加密的话，你最好自己再测试一下。因为，加密次数多了，出来的不一定是一个强度高的密文，也可能会是明文本身，切记切记。
另外，有些人可能会想，那如果我要加密的是中文或者二进制数据，是不是要建立一个超大的密码表，比如把中文字符集放进去？我想说的是，这个加密算法强度不是很高的，如果你非有这个需求，要上身穿着阿玛尼，脚上穿着丁子拖加裤衩，那也是可以的，方法就是用Base64把你的数据转一下码。剩下的就是传一个包含那64个字符的转换表。建议"="符号不要加密。
就像我题目所说的，聊胜于无。有时候，有条裤衩穿着出门，总比一丝不挂的出门要好。前者，你最多是被人说不太文明。而后者，你却铁定要被请去喝茶的。我实现这两个密码最主要的现实意义也在于此，最后，感谢你能坚持看到文章的末尾，如果你有什么疑问或者想法，希望你能告诉我，我也很乐意与你交流。
________________________________________
Footnotes:
1Struts2 + Spring + Hibernate
