Java之Caesar与Vigenere实现


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加密的，就很容易的脱密成原文，虽然有些麻烦，但是这就和用原文是差不多的，即使对加密要求很低也不能低成这样不是？然后是这个替换表，因为是基于字母表的，所以对于英文来说只能加密英文字母，这样就不能被支持了。最后，因为替换是固定的，所以，对于同一个字母，http://www.bkjia.com加密后的字母也是固定的。比如"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不同，加密出来的内容也会不同。至于程序的细节，我想源码会更直观的告诉你的。
  • 1
  • 2
  • 下一页

相关内容