com.github.kaizen4j.algorithm.encrypt.Des Maven / Gradle / Ivy

Go to download
package com.github.kaizen4j.algorithm.encrypt;

import static java.nio.charset.StandardCharsets.UTF_8;

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.Objects;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.apache.commons.codec.binary.Base64;

/**
 * DES 加密类
 *
 * @author liuguowen
 */
public final class Des {

    private static final String DES_DECRYPTION = "DES";

    private Des() {
    }

    /**
     * 根据键值进行加密
     *
     * @param data 待加密数据字符串
     * @param key 加密键字符串
     * @return 加密后的字符串
     */
    public static String encrypt(String data, String key) {
        byte[] binaryData = encrypt(data.getBytes(UTF_8), key.getBytes(UTF_8));
        return Base64.encodeBase64String(binaryData);
    }

    /**
     * 根据键值进行解密
     *
     * @param data 待解密数据字符串
     * @param key 加密键字符串
     * @return 解密后的字符串
     */
    public static String decrypt(String data, String key) {
        if (Objects.nonNull(data)) {
            byte[] binaryData = Base64.decodeBase64(data);
            binaryData = decrypt(binaryData, key.getBytes(UTF_8));
            return new String(binaryData, UTF_8);
        }
        return data;
    }

    /**
     * 根据键值进行加密
     *
     * @param data 待加密数据字节数组
     * @param key 加密键字节数组
     * @return 加密后的字节数组
     */
    private static byte[] encrypt(byte[] data, byte[] key) {
        return doFinal(data, key, Cipher.ENCRYPT_MODE);
    }

    /**
     * 根据键值进行解密
     *
     * @param data 待解密数据字节数组
     * @param key 解密键字节数组
     * @return 解密后的字节数组
     */
    private static byte[] decrypt(byte[] data, byte[] key) {
        return doFinal(data, key, Cipher.DECRYPT_MODE);
    }

    @SuppressWarnings("all")
    private static byte[] doFinal(byte[] data, byte[] key, int mode) {
        try {
            // 生成一个可信任的随机数源
            SecureRandom sr = new SecureRandom();
            // 从原始密钥数据创建 DESKeySpec 对象
            DESKeySpec dks = new DESKeySpec(key);

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

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

            return cipher.doFinal(data);
        } catch (InvalidKeyException | NoSuchAlgorithmException | InvalidKeySpecException | NoSuchPaddingException
                | IllegalBlockSizeException | BadPaddingException e) {
            throw new RuntimeException(e);
        }
    }

}