DES算法要求有一个可信任的随机数源

import java.security.SecureRandom; 

import javax.crypto.Cipher; 
import javax.crypto.SecretKey; 
import javax.crypto.SecretKeyFactory; 
import javax.crypto.spec.DESKeySpec; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
public class PasswordEncryption { 
    private static final String PASSWORD_CRYPT_KEY = "_hrwps20090716pass_"; 

    private final static String DES = "DES"; 

    /** 
     *  
     * 加密 
     *  
     * @param src 
     *            数据源 
     *  
     * @param key 
     *            密钥，长度必须是8的倍数 
     *  
     * @return 返回加密后的数据 
     *  
     * @throws Exception 
     *  
     */ 

       public static byte[] encrypt(byte[] src, byte[] key) throws Exception { 
       
       // DES算法要求有一个可信任的随机数源 
        
        SecureRandom sr = new SecureRandom(); 
        
        // 从原始密匙数据创建DESKeySpec对象 
        
        DESKeySpec dks = new DESKeySpec(key); 
        
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成 
        
        // 一个SecretKey对象 
        
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES); 
        
        SecretKey securekey = keyFactory.generateSecret(dks); 
        
        // Cipher对象实际完成加密操作 
        
        Cipher cipher = Cipher.getInstance(DES); 
        
        // 用密匙初始化Cipher对象 
        
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr); 
        
        // 现在，获取数据并加密 
        
        // 正式执行加密操作 
        
        return cipher.doFinal(src); 
        
       } 
       
       /** 
        *  
        * 解密 
        *  
        * @param src 
        *            数据源 
        *  
        * @param key 
        *            密钥，长度必须是8的倍数 
        *  
        * @return 返回解密后的原始数据 
        *  
        * @throws Exception 
        *  
        */ 
       
       public static byte[] decrypt(byte[] src, byte[] key) throws Exception { 
       
        // DES算法要求有一个可信任的随机数源 
        
        SecureRandom sr = new SecureRandom(); 
        
        // 从原始密匙数据创建一个DESKeySpec对象 
        
        DESKeySpec dks = new DESKeySpec(key); 
        
        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成 
        
        // 一个SecretKey对象 
        
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES); 
        
        SecretKey securekey = keyFactory.generateSecret(dks); 
        
        // Cipher对象实际完成解密操作 
        
        Cipher cipher = Cipher.getInstance(DES); 
        
        // 用密匙初始化Cipher对象 
        
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr); 
        
        // 现在，获取数据并解密 
        
        // 正式执行解密操作 
        
        return cipher.doFinal(src); 
       
       } 
       
       /** 
        *  
        * 密码解密 
        *  
        * @param data 
        *  
        * @return 
        *  
        * @throws Exception 
        *  
        */ 
       
       public final static String decrypt(String data) { 
       
       try { 
       
        return new String(decrypt(hex2byte(data.getBytes()), PASSWORD_CRYPT_KEY.getBytes())); 
       
       } catch (Exception e) { 
       
       } 
       
       return null; 
       
       } 
       
       /** 
        *  
        * 密码加密 
        *  
        * @param password 
        *  
        * @return 
        *  
        * @throws Exception 
        *  
        */ 
       
       public final static String encrypt(String password) { 
       
       try { 
       
       return byte2hex(encrypt(password.getBytes(), PASSWORD_CRYPT_KEY 
       .getBytes())); 
       } catch (Exception e) { 
       
       } 
       
       return null; 
       
       } 
       
       /** 
        *  
        * 二行制转字符串 
        *  
        * @param b 
        *  
        * @return 
        *  
        */ 
       
       public static String byte2hex(byte[] b) { 
       
        String hs = ""; 
        
        String stmp = ""; 
        
        for (int n = 0; n  < b.length; n++) { 
        
        stmp = (java.lang.Integer.toHexString(b[n] & 0XFF)); 
        
        if (stmp.length() == 1) 
        
        hs = hs + "0" + stmp; 
        
        else 
        
        hs = hs + stmp; 
        
        } 
        
        return hs.toUpperCase(); 
        
       } 
         
       public static byte[] hex2byte(byte[] b) { 
        
        if ((b.length % 2) != 0)    
        
        throw new IllegalArgumentException("长度不是偶数"); 
        
        byte[] b2 = new byte[b.length / 2]; 
        
        for (int n = 0; n  < b.length; n += 2) { 
        
        String item = new String(b, n, 2); 
        
        b2[n / 2] = (byte) Integer.parseInt(item, 16); 
        
       } 
       
       return b2;   
       } 
    
    /** 
     * 获得一个随机的加密密码 
     * @param minLen:密码的最小长度 
     * @param maxLen:密码的最大长度 
     * @return 
     */ 
    public String getRandomEncryptPassword(int minLen,int maxLen){ 
        String randPassword=""; 
        String randChar="abcdefghijklmnopqrstuvwxyz1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
        int randNum=(int)(Math.random()*(maxLen-minLen+1))+minLen;  //密码的随机长度(minLen<=length<=maxLen) 
        for(int i=0;i<randNum;i++){ 
            int randCharIndex=(int)(Math.random()*randChar.length()); 
            randPassword=randPassword+randChar.charAt(randCharIndex); 
        } 
        String encryptPassword=this.encrypt(randPassword); 
        return encryptPassword; 
    } 
//    public ActionForward doUserPasswordChange(ActionMapping mapping, ActionForm form, 
//            HttpServletRequest request, HttpServletResponse response) { 
//        
//        String password=request.getParameter("oldpass"); 
//        String newPassword=request.getParameter("confirmPassword"); 
//        TSmUser userLogin=(TSmUser) request.getSession().getAttribute("loginUser"); 
//        PasswordEncryption passWordEncry = new PasswordEncryption(); 
//        if(!userLogin.getUserPassword().equals(passWordEncry.encrypt(password.trim()))){ 
//            request.getSession().setAttribute("msgs", "校验输入的旧密码错误"); 
//            return mapping.findForward("change"); 
//        }else if(userLogin.getUserPassword().equals(passWordEncry.encrypt(newPassword.trim()))){ 
//            request.getSession().setAttribute("msgs", "输入的新密码于旧密码相同"); 
//            return mapping.findForward("change"); 
//        }else{ 
//            userLogin.setUserPassword(passWordEncry.encrypt(newPassword.trim())); 
//            try{ 
//            tsmuserImpl.update(userLogin); 
//            }catch(Exception e){ 
//                request.getSession().setAttribute("msgs", "修改密码失败"); 
//                return mapping.findForward("change"); 
//            } 
//            return mapping.findForward("success"); 
//        } 
//    } 
    
    public static void main(String[] args) { 
        String s=PasswordEncryption.decrypt("4094D62D6C8C89C7"); 
        System.out.println(s); 
    } 

}