2007-05-09

DES 加密

关键字: des
java 代码
 
  1. package encrypt;  
  2.   
  3. import java.security.*;  
  4. import javax.crypto.Cipher;  
  5. import javax.crypto.SecretKey;  
  6. import javax.crypto.SecretKeyFactory;  
  7. import javax.crypto.spec.DESKeySpec;  
  8.   
  9.   
  10. public class DesEncrypt {  
  11.   
  12.     private static final String PASSWORD_CRYPT_KEY = "xredleaf";  
  13.     private final static String DES = "DES";  
  14.   
  15.   
  16.    
  17. /** 
  18.  
  19. * 加密 
  20.  
  21. * @param src 数据源 
  22.  
  23. * @param key 密钥，长度必须是8的倍数 
  24.  
  25. * @return  返回加密后的数据 
  26.  
  27. * @throws Exception 
  28.  
  29. */  
  30.   
  31. public static byte[] encrypt(byte[] src, byte[] key)throws Exception {  
  32.   
  33.        //DES算法要求有一个可信任的随机数源  
  34.   
  35.        SecureRandom sr = new SecureRandom();  
  36.   
  37.        // 从原始密匙数据创建DESKeySpec对象   
  38.   
  39.        DESKeySpec dks = new DESKeySpec(key);  
  40.   
  41.        // 创建一个密匙工厂，然后用它把DESKeySpec转换成  
  42.   
  43.        // 一个SecretKey对象  
  44.   
  45.        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);  
  46.   
  47.        SecretKey securekey = keyFactory.generateSecret(dks);  
  48.   
  49.        // Cipher对象实际完成加密操作  
  50.   
  51.        Cipher cipher = Cipher.getInstance(DES);  
  52.   
  53.        // 用密匙初始化Cipher对象  
  54.   
  55.        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);  
  56.   
  57.        // 现在，获取数据并加密  
  58.   
  59.        // 正式执行加密操作  
  60.   
  61.        return cipher.doFinal(src);  
  62.   
  63.     }  
  64.   
  65.   
  66.   
  67.     /** 
  68.  
  69.     * 解密 
  70.  
  71.     * @param src 数据源 
  72.  
  73.     * @param key 密钥，长度必须是8的倍数 
  74.  
  75.     * @return   返回解密后的原始数据 
  76.  
  77.     * @throws Exception 
  78.  
  79.     */  
  80.   
  81.     public static byte[] decrypt(byte[] src, byte[] key)throws Exception {  
  82.   
  83.        // DES算法要求有一个可信任的随机数源  
  84.   
  85.        SecureRandom sr = new SecureRandom();  
  86.   
  87.        // 从原始密匙数据创建一个DESKeySpec对象  
  88.   
  89.        DESKeySpec dks = new DESKeySpec(key);  
  90.   
  91.        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成  
  92.   
  93.        // 一个SecretKey对象  
  94.   
  95.        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);  
  96.   
  97.        SecretKey securekey = keyFactory.generateSecret(dks);  
  98.   
  99.        // Cipher对象实际完成解密操作  
  100.   
  101.        Cipher cipher = Cipher.getInstance(DES);  
  102.   
  103.        // 用密匙初始化Cipher对象  
  104.   
  105.        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);  
  106.   
  107.        // 现在，获取数据并解密  
  108.   
  109.        // 正式执行解密操作  
  110.   
  111.        return cipher.doFinal(src);  
  112.   
  113.     }  
  114.   
  115.  /** 
  116.  
  117.   * 密码解密 
  118.  
  119.   * @param data 
  120.  
  121.   * @return 
  122.  
  123.   * @throws Exception 
  124.  
  125.   */  
  126.   
  127.  public final static String decrypt(String data){  
  128.   
  129.     try {  
  130.   
  131.      return new String(decrypt(hex2byte(data.getBytes()),  
  132.   
  133.         PASSWORD_CRYPT_KEY.getBytes()));  
  134.   
  135.    }catch(Exception e) {  
  136.   
  137.    }  
  138.   
  139.    return null;  
  140.   
  141.  }  
  142.   
  143.  /** 
  144.  
  145.   * 密码加密 
  146.  
  147.   * @param password 
  148.  
  149.   * @return 
  150.  
  151.   * @throws Exception 
  152.  
  153.   */  
  154.   
  155.  public final static String encrypt(String password){  
  156.   
  157.    try {  
  158.   
  159.      return byte2hex(encrypt(password.getBytes(),PASSWORD_CRYPT_KEY.getBytes()));  
  160.    }catch(Exception e) {  
  161.   
  162.    }  
  163.   
  164.    return null;  
  165.   
  166.  }  
  167.   
  168. /** 
  169.  
  170. * 二行制转字符串 
  171.  
  172. * @param b 
  173.  
  174. * @return 
  175.  
  176. */  
  177.   
  178.  public static String byte2hex(byte[] b) {  
  179.   
  180.        String hs = "";  
  181.   
  182.        String stmp = "";  
  183.   
  184.        for (int n = 0; n < b.length; n++) {  
  185.   
  186.            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));  
  187.   
  188.            if (stmp.length() == 1)  
  189.   
  190.                hs = hs + "0" + stmp;  
  191.   
  192.            else  
  193.   
  194.                hs = hs + stmp;  
  195.   
  196.        }  
  197.   
  198.        return hs.toUpperCase();  
  199.   
  200.   }  
  201.   
  202.    
  203.   
  204.  public static byte[] hex2byte(byte[] b) {  
  205.   
  206.    if((b.length%2)!=0)  
  207.   
  208.       throw new IllegalArgumentException("长度不是偶数");  
  209.   
  210.        byte[] b2 = new byte[b.length/2];  
  211.   
  212.        for (int n = 0; n < b.length; n+=2) {  
  213.   
  214.          String item = new String(b,n,2);  
  215.   
  216.          b2[n/2] = (byte)Integer.parseInt(item,16);  
  217.   
  218.        }  
  219.   
  220.    return b2;  
  221.  }  
  222. }  
评论
发表评论

您还没有登录，请登录后发表评论

redleaf
搜索本博客
最近加入圈子
存档
最新评论
评论排行榜