密码加密工具类 desc

淡淡的烟草味﹌ 2023-02-14 10:46 29阅读 0赞

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("数据库加密");
    // }
    }