DES加密方法

public class DesUtil {

     /**

      * DES 默认key

      */

     private static String desKey;

 

     /**

      * DES解密 (采用默认key)

      *

      * @param desKey

      * @param dataSource

      * @throws IllegalBlockSizeException

      * @throws BadPaddingException

      * @throws InvalidKeyException

      * @throws NoSuchAlgorithmException

      * @throws NoSuchPaddingException

      * @throws InvalidKeySpecException

      * @throws UnsupportedEncodingException

      */

     public static String decode(String dataSource) throws Exception {

         if (dataSource != null ) {

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

             byte rawKeyData[] = desKey.getBytes( "UTF-8" );

             // SecureRandom sr = new SecureRandom();

             // 从原始密匙数据创建一个DESKeySpec对象

             DESKeySpec dks = new DESKeySpec(rawKeyData);

             // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象

             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );

             SecretKey key = keyFactory.generateSecret(dks);

             // Cipher对象实际完成解密操作

             Cipher cipher = Cipher.getInstance( "DES" );

             // 用密匙初始化Cipher对象

             cipher.init(Cipher.DECRYPT_MODE, key);

             // 正式执行解密操作

             byte decryptedData[] = cipher.doFinal(Base64.decode(dataSource, Base64.DEFAULT));

             return new String(decryptedData);

         }

         return null ;

     }

 

     /**

      * DES解密

      *

      * @param desKey

      * @param dataSource

      * @throws IllegalBlockSizeException

      * @throws BadPaddingException

      * @throws InvalidKeyException

      * @throws NoSuchAlgorithmException

      * @throws NoSuchPaddingException

      * @throws InvalidKeySpecException

      * @throws UnsupportedEncodingException

      */

     public static String decode(String desKey, String dataSource) throws Exception {

         if (dataSource != null && desKey != null ) {

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

             byte rawKeyData[] = desKey.getBytes( "UTF-8" );

             // SecureRandom sr = new SecureRandom();

             // 从原始密匙数据创建一个DESKeySpec对象

             DESKeySpec dks = new DESKeySpec(rawKeyData);

             // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成一个SecretKey对象

             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );

             SecretKey key = keyFactory.generateSecret(dks);

             // Cipher对象实际完成解密操作

             Cipher cipher = Cipher.getInstance( "DES" );

             // 用密匙初始化Cipher对象

             cipher.init(Cipher.DECRYPT_MODE, key);

             // 正式执行解密操作

             byte decryptedData[] = cipher.doFinal(Base64.decode(dataSource, Base64.DEFAULT));

             return new String(decryptedData);

         }

         return null ;

     }

 

     /**

      * DES加密 (采用默认key)

      *

      * @param desKey

      * @param dataSource

      * @throws InvalidKeyException

      * @throws NoSuchAlgorithmException

      * @throws IllegalBlockSizeException

      * @throws BadPaddingException

      * @throws NoSuchPaddingException

      * @throws InvalidKeySpecException

      * @throws UnsupportedEncodingException

      */

     public static String encode(Object dataSource) throws Exception {

         if (dataSource != null ) {

             byte rawKeyData[] = desKey.getBytes( "UTF-8" );

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

             // SecureRandom sr = new SecureRandom();

             // 从原始密匙数据创建一个DESKeySpec对象

             DESKeySpec dks = new DESKeySpec(rawKeyData);

             // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象

             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );

             SecretKey key = keyFactory.generateSecret(dks);

             // Cipher对象实际完成加密操作

             Cipher cipher = Cipher.getInstance( "DES" );

             // 用密匙初始化Cipher对象

             cipher.init(Cipher.ENCRYPT_MODE, key);

             // 现在，获取数据并加密

             String str = String.valueOf(dataSource);

             byte [] encryptedData = cipher.doFinal(str.getBytes( "UTF-8" ));

             return Base64.encodeToString(encryptedData, Base64.DEFAULT);

         }

         return null ;

     }

 

     /**

      * DES加密

      *

      * @param desKey

      * @param dataSource

      * @throws InvalidKeyException

      * @throws NoSuchAlgorithmException

      * @throws IllegalBlockSizeException

      * @throws BadPaddingException

      * @throws NoSuchPaddingException

      * @throws InvalidKeySpecException

      * @throws UnsupportedEncodingException

      */

     public static String encode(String desKey, Object dataSource) throws Exception {

         if (desKey != null && dataSource != null ) {

             byte rawKeyData[] = desKey.getBytes( "UTF-8" );

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

             // SecureRandom sr = new SecureRandom();

             // 从原始密匙数据创建一个DESKeySpec对象

             DESKeySpec dks = new DESKeySpec(rawKeyData);

             // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象

             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );

             SecretKey key = keyFactory.generateSecret(dks);

             // Cipher对象实际完成加密操作

             Cipher cipher = Cipher.getInstance( "DES" );

             // 用密匙初始化Cipher对象

             cipher.init(Cipher.ENCRYPT_MODE, key);

             // 现在，获取数据并加密

             String str = String.valueOf(dataSource);

             byte [] encryptedData = cipher.doFinal(str.getBytes( "UTF-8" ));

             return Base64.encodeToString(encryptedData, Base64.DEFAULT);

         }

         return null ;

     }

 

     /**

      * 获得DES 默认key

      * @return

      */

     public static String getDesKey() {

         return desKey;

     }

 

     /**

      * 设置DES 默认key

      * @param desKey

      */

     public static void setDesKey(String desKey) {

         DesUtil.desKey = desKey;

     }

 

}