Java實現RSA加密&AES加密&DES加密

RSA

package com.demo;

import org.springframework.util.StringUtils;

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * RSA 加密算法是目前最有影響力的 公鑰加密算法，並且被普遍認為是目前 最優秀的公鑰方案 之一。RSA 是第一個能同時用於 加密 和 數字簽名 的算法，它能夠 抵抗 到目前為止已知的 所有密碼攻擊，已被 ISO 推薦為公鑰數據加密標准。
 */
public class RSAUtils {

    /**
     * 加密（對外暴露）
     * 如果使用 公鑰 對數據 進行加密，只有用對應的 私鑰 才能 進行解密。
     * 如果使用 私鑰 對數據 進行加密，只有用對應的 公鑰 才能 進行解密。
     *
     * @param keyStr
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptData(String keyStr, String data, Boolean isPublicKey) throws Exception {
        if (StringUtils.isEmpty(keyStr)) {
            return "";
        }
        return encryptBASE64(encrypt(getKey(keyStr, isPublicKey), data.getBytes()));
    }

    /**
     * 解密（對外暴露）
     * 如果使用 公鑰 對數據 進行加密，只有用對應的 私鑰 才能 進行解密。
     * 如果使用 私鑰 對數據 進行加密，只有用對應的 公鑰 才能 進行解密。
     *
     * @param keyStr
     * @param data
     * @return
     * @throws Exception
     */
    public static String decryptData(String keyStr, String data, Boolean isPublicKey) throws Exception {
        if (StringUtils.isEmpty(keyStr)) {
            return "";
        }
        return new String(decrypt(getKey(keyStr, isPublicKey), decryptBASE64(data)), "UTF-8");
    }

    /**
     * 加密
     *
     * @param key
     * @param srcBytes
     * @return
     */
    private static byte[] encrypt(Key key, byte[] srcBytes) {
        if (key != null) {
            try {
                //Cipher負責完成加密或解密工作，基於RSA
                Cipher cipher = Cipher.getInstance("RSA");
                //對Cipher對象進行初始化
                cipher.init(Cipher.ENCRYPT_MODE, key);
                //加密，並返回
                return cipher.doFinal(srcBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 解密
     *
     * @param key
     * @param encBytes
     * @return
     */
    private static byte[] decrypt(Key key, byte[] encBytes) {
        if (key != null) {
            try {
                Cipher cipher = Cipher.getInstance("RSA");
                //對Cipher對象進行初始化
                cipher.init(Cipher.DECRYPT_MODE, key);
                //解密並返回結果
                return cipher.doFinal(encBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 根據key獲取公有或者私有key對象
     *
     * @param keyStr
     * @param isPublicKey
     * @return
     * @throws Exception
     */
    private static Key getKey(String keyStr, Boolean isPublicKey) throws Exception {
        if (isPublicKey) {
            return getPublicKey(keyStr);
        } else {
            return getPrivateKey(keyStr);
        }
    }

    /**
     * 根據公有key獲取公有key對象
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static RSAPublicKey getPublicKey(String key) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(key);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return (RSAPublicKey) keyFactory.generatePublic(keySpec);
    }

    /**
     * 根據私有key獲取私有對象
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static RSAPrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
    }

    /**
     * 獲取公有/私有Key
     *
     * @return
     */
    private static KeyPair getRSAKey() {
        KeyPair keyPair = null;
        try {
            //生成公鑰和私鑰對，基於RSA算法生成對象
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            //初始化密鑰對生成器，密鑰大小為1024位
            keyPairGen.initialize(1024);
            //生成一個密鑰對，保存在keyPair中
            keyPair = keyPairGen.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return keyPair;
    }

    /**
     * 對字符串進行BASE64Decoder
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static byte[] decryptBASE64(String key) {
        return Base64.getDecoder().decode(key);
    }

    /**
     * 對字節數組進行BASE64Encoder
     *
     * @param key
     * @return
     * @throws Exception
     */
    private static String encryptBASE64(byte[] key) {
        return Base64.getEncoder().encodeToString(key);
    }

    public static void main(String[] args) {
        // 生成的一對key保存好
        try {
            //得到私鑰和公鑰
            KeyPair keyPair = getRSAKey();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

            String pubKey = encryptBASE64(publicKey.getEncoded());
            String priKey = encryptBASE64(privateKey.getEncoded());
            System.out.println("公鑰：" + pubKey);
            System.out.println("私鑰：" + priKey);

            // 測試
            String message = "QWERDF";

            System.out.println("明文：" + message);
            String jiami = encryptData(pubKey, message, true);
            System.out.println("公鑰加密后：" + jiami);
            String jiemi = decryptData(priKey, jiami, false);
            System.out.println("用私鑰解密后的結果是:" + jiemi);

            jiami = encryptData(priKey, message, false);
            System.out.println("私鑰加密后：" + jiami);
            jiemi = decryptData(pubKey, jiami, true);
            System.out.println("用公鑰解密后的結果是:" + jiemi);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

輸出：

公鑰：MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCRl5SHQ7b6oyqAhViqiEe1ioC/xj3Wbolopv0mXyWkV8q/SMnbvl0PCeNhoMqHEr7ch2UlLL9130vqrOqrTMEDOX+7VzNEO2EVrcQIbZv69Tz6nIaH5IHuSo2zlySDtEV8q1/PwlvbSLZDsAKGmMj4jPaJPTKaseqN9CVTkV5gfQIDAQAB
私鑰：MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJGXlIdDtvqjKoCFWKqIR7WKgL/GPdZuiWim/SZfJaRXyr9Iydu+XQ8J42GgyocSvtyHZSUsv3XfS+qs6qtMwQM5f7tXM0Q7YRWtxAhtm/r1PPqchofkge5KjbOXJIO0RXyrX8/CW9tItkOwAoaYyPiM9ok9Mpqx6o30JVORXmB9AgMBAAECgYAIWKU2H+akdaghGAPeOtPJj3gUBlxTJ6EO88u9YGT7B+Fil9yikUYqb4mudhZGKgfxAn4E5IzRSAzFFkaZrVu/KkQEl0+V6QUSV+VlNk59Fm+71Vvyc91U1P5pHu8B22ZNx6n+QUw1oNlYRMTpB9rPDROpQ2McP85qLSdjc6oELQJBANr/geEHNvropBDSgoAun24CxrN5wPbz55aq6WL3HP4Y6ocfHKKantboe7DeQqi4ZJOuPUzV//a3tRaIFjdn5ysCQQCqMPzubRwiFN4GcO/Esz3khcBFdkURI2iY0WgPPK3A3G02Uz05EjDbWoyjr7E/3fTxq57t847hcqB5wFu88AL3AkEAyFeKR4REJdGBleoefIkqTIe5oyK1BrYmnM0J6QFLwqCknKw3lAGDYfMYhLsvnA3j5L43Uf1LxjZVMaGZQWKKNQJAV+rMjmJg+R4sf8lRoxww6d9KLtfk3/CZtO/gQJbI72svI7QmWVgTUw1Yv6of920yfrF4fVWnRsFPMvXyrgySiwJBAIc6ojV4uv92+1vFpirbBLqyBV0YK4hok3EO+Il5iWZK5VJYuRIQsBniT4X+BqA9653CqFoLHt+0LCjmkndm70Q=
明文：QWERDF
公鑰加密后：d/CSSxZ76bgIuUjZELpvwCO1Uae4fg5HUHqYAZScvl9sAoDX/k7lg2RMcct5yqNu0PMMMmvG4Km1i86kfzBXVgFiHDhiQV0uIAXawBcC43qoa9nD7Hqgkd3+DVlWz5NGNvI1ROQCsQ+jBYDIHtSOOBKaIxp3/qoifmwlMBBY/Ok=
用私鑰解密后的結果是:QWERDF
私鑰加密后：hEWfdnBuCg1vIRK7iQUhCe1wDxJfXh67nLlkMD/PpyjAOQQm1JrVXkBVtPcwIWOVVQFCgcZpqg2M51z3LtdcLTAuxHQKY6ypKkOTg6ziK/egx4SHxjvRZRn4kYjuMpQIiUoSdE7xmp3HRrlHmOhDTrTONawKSVOh7vcBGncNr90=
用公鑰解密后的結果是:QWERDF

　　

AES

package com.demo;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * AES 本身就是為了取代 DES 的，AES 具有更好的 安全性、效率 和 靈活性
 */
public class AESUtils {

    /*
     * 加密（對外暴露）
     */
    public static String encryptData(String privateKey, String content) throws Exception {
        KeyGenerator keygen = getKeyGenerator(privateKey);
        SecretKey key = new SecretKeySpec(keygen.generateKey().getEncoded(), "AES");
        return Base64.getEncoder().encodeToString(encrypt(key, content.getBytes("UTF-8")));
    }

    /*
     * 解密（對外暴露）
     */
    public static String decryptData(String privateKey, String content) throws Exception {
        KeyGenerator keygen = getKeyGenerator(privateKey);
        SecretKey key = new SecretKeySpec(keygen.generateKey().getEncoded(), "AES");
        return new String(decrypt(key, Base64.getDecoder().decode(content)), "UTF-8");
    }

    private static KeyGenerator getKeyGenerator(String privateKey) throws NoSuchAlgorithmException {
        KeyGenerator keygen = KeyGenerator.getInstance("AES");
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(privateKey.getBytes());
        keygen.init(128, secureRandom);
        return keygen;
    }

    private static byte[] encrypt(Key key, byte[] srcBytes) {
        if (key != null) {
            try {
                // Cipher負責完成加密或解密工作，基於AES
                Cipher cipher = Cipher.getInstance("AES");
                // 對Cipher對象進行初始化
                cipher.init(Cipher.ENCRYPT_MODE, key);
                // 加密，保存並返回
                return cipher.doFinal(srcBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private static byte[] decrypt(Key key, byte[] encBytes) {
        if (key != null) {
            try {
                Cipher cipher = Cipher.getInstance("AES");
                //對Cipher對象進行初始化
                cipher.init(Cipher.DECRYPT_MODE, key);
                //解密
                return cipher.doFinal(encBytes);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }


    public static void main(String[] args) throws Exception {
        String privateKey = "ABC";
        String content = "ASD456";
        String m = encryptData(privateKey, content);
        System.out.println("根據私鑰：" + privateKey + "，加密后的密文是：" + m);
        System.out.println("根據私鑰：" + privateKey + "，解密后的明文是：" + decryptData(privateKey, m));
    }

}

輸出：

根據私鑰：ABC，加密后的密文是：6vLE6e1f//pq9e+ZmczfxQ==
根據私鑰：ABC，解密后的明文是：ASD456

　　

DES

package com.demo;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import java.security.Key;
import java.security.SecureRandom;
import java.util.Base64;


public class DESUtils {

    private static Key key;
    private static final String PRIVATE_KEY = "ABC";

    static {
        try {
            KeyGenerator generator = KeyGenerator.getInstance("DES");
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(PRIVATE_KEY.getBytes());
            generator.init(secureRandom);
            key = generator.generateKey();
            generator = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 加密，返回BASE64的加密字符串
     * @param str
     * @return
     */
    public static String getEncryptString(String str) throws Exception {
        byte[] strBytes = str.getBytes("UTF-8");
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptStrBytes = cipher.doFinal(strBytes);
        return Base64.getEncoder().encodeToString(encryptStrBytes);
    }

    /**
     * 對BASE64加密字符串進行解密
     * @param str
     * @return
     */
    public static String getDecryptString(String str) throws Exception {
        byte[] strBytes = Base64.getDecoder().decode(str);
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] encryptStrBytes = cipher.doFinal(strBytes);
        return new String(encryptStrBytes, "UTF-8");
    }

    public static void main(String[] args) throws Exception {
        String name = "catdog";
        String password = "Cat<%1?2>Dog";
        String encryname = getEncryptString(name);
        String encrypassword = getEncryptString(password);
        System.out.println("加密：" + encryname);
        System.out.println("加密：" + encrypassword);

        System.out.println("解密：" + getDecryptString(encryname));
        System.out.println("解密：" + getDecryptString(encrypassword));
    }
}

輸出：

加密：RnvNku4diHc=
加密：/ru3Rho55Ji9RGcOleTvQA==
解密：catdog
解密：Cat<%1?2>Dog