Java的Des加解密工具

Des是对称加密,加密速度快,但因为是对称加密,容易破解,适用于不是很敏感的数据,但需要简单加密的场景!

本次分享的为Des加解密工具类,有3个工具类,选择自己适用的就好

分别是DesUtil.java DesUtils.java Base64Utils.java DesFileUtils.java

DesUtils.java

@Slf4j
public class DesUtils  {

    private final static String DES = "DES";

    /**
     * Description 根据键值进行加密
     *
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     * @throws Exception
     */
    public static byte[] encryptBytes(byte[] data, byte[] key) throws Exception {
        return encrypt(data, key);
    }

    /**
     * Description 根据键值进行加密
     *
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key){
        byte[] bt = encrypt(data.getBytes(), key.getBytes());
        return Base64Utils.encode(bt);
    }

    /**
     * Description 根据键值进行解密
     *
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws Exception {

        if (data == null)
            return null;
        byte[] buf = Base64Utils.decode(data);
        byte[] bt = decrypt(buf, key.getBytes());
        return new String(bt);
    }
    /**
     * Description 根据键值进行解密
     *
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     */
    public static byte[] decryptBytes(byte[] data, byte[] key){
        return decrypt(data, key);


    }

    /**
     * Description 根据键值进行加密
     *
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key){

        byte[] encryptData = null;

        try {
            SecureRandom sr = new SecureRandom(); // 生成一个可信任的随机数源
            DESKeySpec dks = new DESKeySpec(key);   // 从原始密钥数据创建DESKeySpec对象

            // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
            SecretKey securekey = keyFactory.generateSecret(dks);

            Cipher cipher = Cipher.getInstance(DES);  // Cipher对象实际完成加密操作
            cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);  // 用密钥初始化Cipher对象

            encryptData = cipher.doFinal(data);
        }catch (InvalidKeyException | NoSuchAlgorithmException | InvalidKeySpecException
            | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e){

            log.error("des加密异常", e);
        }
        return encryptData;
    }

    /**
     * Description 根据键值进行解密
     * @param data
     * @param key
     *            加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, byte[] key) {

        SecureRandom sr = new SecureRandom();  // 生成一个可信任的随机数源
        byte[] originData = null;
        try {
            DESKeySpec dks = new DESKeySpec(key);  // 从原始密钥数据创建DESKeySpec对象

            // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
            SecretKey securekey = keyFactory.generateSecret(dks);

            Cipher cipher = Cipher.getInstance(DES); // Cipher对象实际完成解密操作
            cipher.init(Cipher.DECRYPT_MODE, securekey, sr);  // 用密钥初始化Cipher对象

            originData = cipher.doFinal(data);

        }catch (InvalidKeyException | NoSuchAlgorithmException | InvalidKeySpecException
            | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e){

            log.error("des解密异常", e);
        }

        return originData;
    }


    public static void main(String[] args) throws Exception {

        String s = "nihao你好,。hello！";
        String key = "fd6b65de3c826c385edc0705d27bc1bf";
        String enStr = encrypt(s, key);
        System.out.println("--------enStr=" + enStr);

        String deStr = decrypt(enStr, "fd6b65de3c826c385edc0705d27bc1bf");
        System.out.println("--------deStr=" + deStr);

    }

}

Base64Utils.java

/**
 * BASE64编码解码工具包
 */
public class Base64Utils {

/**
     * 文件读取缓冲区大小
     */
private static final int CACHE_SIZE = 1024;

/**
     * <p>
     * BASE64字符串解码为二进制数据
     * </p>
     * 
     * @param base64
     * @return
     * @throws Exception
     */
public static byte[] decode(String base64) throws Exception{
return Base64.decode(base64.getBytes());
    }

/**
     * <p>
     * 二进制数据编码为BASE64字符串
     * </p>
     * 
     * @param bytes
     * @return
     * @throws Exception
     */
public static String encode(byte[] bytes) {
return new String(Base64.encode(bytes));
    }

/**
     * <p>
     * 将文件编码为BASE64字符串
     * </p>
     * <p>
     * 大文件慎用，可能会导致内存溢出
     * </p>
     * 
     * @param filePath 文件绝对路径
     * @return
     * @throws Exception
     */
public static String encodeFile(String filePath) throws Exception {
byte[] bytes = fileToByte(filePath);
return encode(bytes);
    }

/**
     * <p>
     * BASE64字符串转回文件
     * </p>
     * 
     * @param filePath 文件绝对路径
     * @param base64 编码字符串
     * @throws Exception
     */
public static void decodeToFile(String filePath, String base64) throws Exception {
byte[] bytes = decode(base64);
        byteArrayToFile(bytes, filePath);
    }

/**
     * <p>
     * 文件转换为二进制数组
     * </p>
     * 
     * @param filePath 文件路径
     * @return
     * @throws Exception
     */
public static byte[] fileToByte(String filePath) throws Exception {
byte[] data = new byte[0];
        File file = new File(filePath);
if (file.exists()) {
            FileInputStream in = new FileInputStream(file);
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            }
            out.close();
            in.close();
            data = out.toByteArray();
         }
return data;
    }

/**
     * <p>
     * 二进制数据写文件
     * </p>
     * 
     * @param bytes 二进制数据
     * @param filePath 文件生成目录
     */
public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
        InputStream in = new ByteArrayInputStream(bytes);   
        File destFile = new File(filePath);
if (!destFile.getParentFile().exists()) {
            destFile.getParentFile().mkdirs();
        }
        destFile.createNewFile();
        OutputStream out = new FileOutputStream(destFile);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {   
            out.write(cache, 0, nRead);
            out.flush();
        }
        out.close();
        in.close();
    }


}

DesFileUtils.java

/**
 * @author wcw
 * @date 2018年8月7日 下午12:45:25
 * 
 */
@Log4j
public class DesFileUtils {
/** 加密解密的key */
private Key mKey;
/** 解密的密码 */
private Cipher mDecryptCipher;
/** 加密的密码 */
private Cipher mEncryptCipher;

public DesFileUtils(String key) throws Exception {
synchronized (this) {
            initKey(key);
            initCipher();
        }
    }

/**
     * 创建一个加密解密的key
     * 
     * @param keyRule
     */
private void initKey(String keyRule) {
byte[] keyByte = keyRule.getBytes();
// 创建一个空的八位数组,默认情况下为0
byte[] byteTemp = new byte[8];
// 将用户指定的规则转换成八位数组
for (int i = 0; i < byteTemp.length && i < keyByte.length; i++) {
            byteTemp[i] = keyByte[i];
        }
        mKey = new SecretKeySpec(byteTemp, "DES");
    }

/***
     * 初始化加载密码
     * 
     * @throws Exception
     */
private void initCipher() throws Exception {
        mEncryptCipher = Cipher.getInstance("DES");
        mEncryptCipher.init(Cipher.ENCRYPT_MODE, mKey);
        mDecryptCipher = Cipher.getInstance("DES");
        mDecryptCipher.init(Cipher.DECRYPT_MODE, mKey);
    }

/**
     * 加密文件
     * 
     * @param filePath
     *            需要加密的文件路径
     * @param savePath
     *            加密后保存的位置
     */
public void encryptFile(String filePath, String savePath) {
        FileInputStream in = null;
        CipherInputStream cin = null;
        OutputStream os = null;
try {
            in = new FileInputStream(filePath);
            cin = new CipherInputStream(in, mEncryptCipher);
            os = new FileOutputStream(savePath);
byte[] bytes = new byte[1024];
int len = -1;
while ((len = cin.read(bytes)) > 0) {
                os.write(bytes, 0, len);
                os.flush();
            }
        } catch (Exception e) {
            log.error("文件加密失败,filePath=" + filePath, e);
throw new RuntimeException("文件加密失败");
        } finally {
if (null != in) {
try {
                    in.close();
                } catch (IOException e) {
                    log.error("输入文件流关闭失败", e);
                }
            }
if (null != cin) {
try {
                    cin.close();
                } catch (IOException e) {
                    log.error("加密输入文件流关闭失败", e);
                }

            }
if (null != os) {
try {
                    os.close();
                } catch (IOException e) {
                    log.error("输出文件流关闭失败", e);
                }

            }
        }
    }

/**
     * 解密文件
     * 
     * @param filePath
     * @param outPath
     */
public void decryptFile(String filePath, String outPath) {
        FileInputStream in = null;
        CipherInputStream cin = null;
        OutputStream os = null;
try {
            in = new FileInputStream(filePath);
            cin = new CipherInputStream(in, mDecryptCipher);
            os = new FileOutputStream(outPath);
byte[] buffer = new byte[1024];
int i;
while ((i = cin.read(buffer)) != -1) {
                os.write(buffer, 0, i);
            }
        } catch (Exception e) {
            log.error("文件解密失败,filePath=" + filePath, e);
throw new RuntimeException("文件解密失败");
        } finally {
if (null != in) {
try {
                    in.close();
                } catch (IOException e) {
                    log.error("输入文件流关闭失败", e);
                }
            }
if (null != cin) {
try {
                    cin.close();
                } catch (IOException e) {
                    log.error("加密输入文件流关闭失败", e);
                }

            }
if (null != os) {
try {
                    os.close();
                } catch (IOException e) {
                    log.error("输出文件流关闭失败", e);
                }

            }
        }
    }

/**
     * @Title: encryptFile
     * @Description: 加密文件
     * @param publicKey
     * @param sourceFilepath
     * @param localFilePath
     * 设定文件 @return void 返回类型 @throws
     */
public static void encryptFile(String publicKey, String sourceFilepath, String localFilePath) {
        FileOutputStream fos = null;
try {
byte[] data = Base64Utils.fileToByte(sourceFilepath);
byte[] desData = DesUtil.encryptBytes(data,publicKey.getBytes());
            fos = new FileOutputStream(new File(localFilePath));
            fos.write(desData);
        } catch (Exception e) {
            log.error("文件加密失败,zaFilePath:" + sourceFilepath, e);
throw new RuntimeException("文件加密失败");
        } finally {
if (fos != null) {
try {
                    fos.close();
                } catch (IOException e) {
                    log.error("输入文件流关闭失败",e);
                }
            }
        }
    }

/**
     * @Title: decryptFileFromPartner
     * @Description: 解密合作方的文件
     * @param  sourceFilePath
     * @param  localFilePath
     * 设定文件 @return void 返回类型 @throws
     */
public static void decryptFile(String publicKey, String sourceFilePath, String localFilePath) {
        FileOutputStream fos = null;
try {
byte[] data = Base64Utils.fileToByte(sourceFilePath);
byte[] desData = DesUtil.decryptBytes(data,publicKey.getBytes());
            fos = new FileOutputStream(new File(localFilePath));
            fos.write(desData);
        } catch (Exception e) {
            log.error("文件解密失败,filePath:" + sourceFilePath, e);
throw new RuntimeException("文件解密失败");
        } finally {
if (fos != null) {
try {
                    fos.close();
                } catch (IOException e) {
                    log.error("输入文件流关闭失败",e);
                }
            }
        }
    }

public static void main(String[] args) throws Exception {
/*DesFileUtils.encryptFile("fd6b65de3c826c385edc0705d27bc1bf","C:\\Users\\chenghao\\Desktop\\electronic_policy_1158576626.pdf", "C:\\Users\\chenghao\\Desktop\\electronic_policy_1158576626_des.pdf");
        System.out.println("success");*/
        DesFileUtils.decryptFile("fd6b65de3c826c385edc0705d27bc1bf","C:\\Users\\chenghao\\Desktop\\loan_detail_20180905_des.csv", "C:\\Users\\chenghao\\Desktop\\3.csv");
        System.out.println("success");
    }
}

Java的Des加解密工具

继续阅读

标准MD5加密工具类

1小时内加密你的生活：简易隐私保护攻略

币安赵长鹏罕见发文：加密货币对国家战略的六大意义吸引资金吸引人才创造本地就业机会政府税收增加行业增长

JAVA实用工具类-拼音转换-->

java判断是否为汉字

查询任意时间段的日期（java小工具）

Java实用DateUtils工具类

java生成二维码工具（支持叠加到大图和附加logo）

基于JAVA的SM4文件加密解密，可以直接使用SM4文件加密

Java生成支持中文的pdf工具类(html+freemark)

java后端原生发送http请求方法