密码加密工具类 desc

maven依赖

<dependency>
   <groupId>commons-lang</groupId>
   <artifactId>commons-lang</artifactId>
   <version>2.6</version>
</dependency>

工具类代码

package com.example.cc.util;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import java.security.SecureRandom;
import java.util.Properties;

/**
 * 通过3重DES算法，加密或解密数据
 */
@Component
public class DESUtil {

   private static Log log = LogFactory.getLog(DESUtil.class);
   /**
    * 3重DES
    */
   private final static String DES = "DESede";

   /**
    * DES加密KEY 默认的key 长度必须是24位
    */

   public final static String DES_KEY = "";//自己添加

   /**
    * 加密
    * 
    * @param src
    *            数据源
    * @param key
    *            密钥，长度必须是24位
    * @return 返回加密后的数据
    * @throws Exception
    */
   public static byte[] encrypt(byte[] src, byte[] key)
         throws RuntimeException {
      // DES算法要求有一个可信任的随机数源
      try {
         SecureRandom sr = new SecureRandom();
         // 从原始密匙数据创建DESKeySpec对象
         DESedeKeySpec dks = new DESedeKeySpec(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);
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * 解密
    * 
    * @param src
    *            数据源
    * @param key
    *            密钥，长度必须是24位
    * @return 返回解密后的原始数据
    * @throws Exception
    */
   public static byte[] decrypt(byte[] src, byte[] key)
         throws RuntimeException {
      try { // DES算法要求有一个可信任的随机数源
         SecureRandom sr = new SecureRandom();
         // 从原始密匙数据创建一个DESKeySpec对象
         DESedeKeySpec dks = new DESedeKeySpec(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);
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * DES数据解密
    * 
    * @param data
    * @return
    * @throws Exception
    */
   public final static String decrypt(String data) {
      if (data == null) {
         return null;
      }
      try{
         return new String(decrypt(hex2byte(data.getBytes()), DES_KEY.getBytes()));
      }catch (RuntimeException e) {
         // TODO: handle exception
         e.getMessage();
         return data;
      }
   }
   
   public final static String decrypt(String key,Properties props){
      String str = props.getProperty(key);
      if(StringUtils.isNotBlank(str)){
         try{
         str = decrypt(str);
         props.setProperty(key, str);
         }catch(Exception e){
            e.getMessage();
         }
      }
      return str;
   }

   /**
    * DES数据解密
    * 
    * @param data
    * @param key
    *            密钥
    * @return
    * @throws Exception
    */
   public final static String decrypt(String data, String key) {
      if (data == null || key == null) {
         return null;
      }
      try{
         return new String(decrypt(hex2byte(data.getBytes()), key.getBytes()));
      }catch (RuntimeException e) {
         // TODO: handle exception
         e.getMessage();
         return data;
      }
   }

   /**
    * DES数据加密,使用默认的key
    * 
    * @param data
    * @return
    * @throws Exception
    */
   public final static String encrypt(String data) {
      if (data != null)
         try {
            return byte2hex(encrypt(data.getBytes(), DES_KEY.getBytes()));
         } catch (Exception e) {
            throw new RuntimeException(e);
         }
      return null;
   }

   /**
    * DES数据加密
    * 
    * @param data
    * @param key
    *            密钥
    * @return
    * @throws Exception
    */
   public final static String encrypt(String data, String key) {
      if (data != null && key != null)
         try {
            return byte2hex(encrypt(data.getBytes(), key.getBytes()));
         } catch (Exception e) {
            throw new RuntimeException(e);
         }
      return null;
   }

   /**
    * 二行制转字符串
    * 
    * @param b
    * @return
    */
   private static String byte2hex(byte[] b) {
      StringBuilder hs = new StringBuilder();
      String stmp;
      for (int n = 0; b != null && n < b.length; n++) {
         stmp = Integer.toHexString(b[n] & 0XFF);
         if (stmp.length() == 1)
            hs.append('0');
         hs.append(stmp);
      }
      return hs.toString().toUpperCase();
   }

   private 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;
   }

// public static void main(String[] args) {
//    log.info("ftp加密");
//    log.info(encrypt("sjy123"));
//    log.info(decrypt("08A189769D1B82AA"));
//    log.info("数据库加密");
// }
}