Java實現AES和RSA演算法

FKNIGHT0X發表於2018-08-17
Java演算法

說明：

本文是用 Java1.8 官方的工具類進行的封裝，兩種加密演算法的原理參考：

AES：https://blog.csdn.net/gulang03/article/details/81175854

RSA：https://blog.csdn.net/gulang03/article/details/81176133

實現類：

  AESUtil:

package com.fknight.sbsmdemo.tools;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * AES 加密方法，是對稱的密碼演算法(加密與解密的金鑰一致)，這裡使用最大的 256 位的金鑰
 */
public class AESUtil {
    /**
     * 獲得一個 金鑰長度為 256 位的 AES 金鑰，
     * @return 返回經 BASE64 處理之後的金鑰字串
     */
    public static String getStrKeyAES() throws NoSuchAlgorithmException, UnsupportedEncodingException {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        SecureRandom secureRandom = new SecureRandom(String.valueOf(System.currentTimeMillis()).getBytes("utf-8"));
        keyGen.init(256, secureRandom);   // 這裡可以是 128、192、256、越大越安全
        SecretKey secretKey = keyGen.generateKey();
        return Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }

    /**
     *  將使用 Base64 加密後的字串型別的 secretKey 轉為 SecretKey
     * @param strKey
     * @return SecretKey
     */
    public static SecretKey strKey2SecretKey(String strKey){
        byte[] bytes = Base64.getDecoder().decode(strKey);
        SecretKeySpec secretKey = new SecretKeySpec(bytes, "AES");
        return secretKey;
    }

    /**
     * 加密
     * @param content 待加密內容
     * @param secretKey 加密使用的 AES 金鑰
     * @return 加密後的密文 byte[]
     */
    public static byte[] encryptAES(byte[] content, SecretKey secretKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        return cipher.doFinal(content);
    }

    /**
     * 解密
     * @param content 待解密內容
     * @param secretKey 解密使用的 AES 金鑰
     * @return 解密後的明文 byte[]
     */
    public static byte[] decryptAES(byte[] content, SecretKey secretKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        return cipher.doFinal(content);
    }
}

  RSAUtil:

package com.fknight.sbsmdemo.tools;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * RSA 是非對稱的密碼演算法，金鑰分公鑰和私鑰，公鑰用來加密，私鑰用於解密
 */

public class RSAUtil {
    /**
     * 生成金鑰對：金鑰對中包含公鑰和私鑰
     * @return 包含 RSA 公鑰與私鑰的 keyPair
     * @throws NoSuchAlgorithmException
     * @throws UnsupportedEncodingException
     */
    public static KeyPair getKeyPair() throws NoSuchAlgorithmException, UnsupportedEncodingException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");    // 獲得RSA金鑰對的生成器例項
        SecureRandom secureRandom = new SecureRandom(String.valueOf(System.currentTimeMillis()).getBytes("utf-8")); // 說的一個安全的隨機數
        keyPairGenerator.initialize(2048, secureRandom);    // 這裡可以是1024、2048 初始化一個金鑰對
        KeyPair keyPair = keyPairGenerator.generateKeyPair();   // 獲得金鑰對
        return keyPair;
    }

    /**
     * 獲取公鑰 (並進行Base64編碼，返回一個 Base64 編碼後的字串)
     * @param keyPair
     * @return 返回一個 Base64 編碼後的公鑰字串
     */
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    /**
     * 獲取私鑰(並進行Base64編碼，返回一個 Base64 編碼後的字串)
     * @param keyPair
     * @return 返回一個 Base64 編碼後的私鑰字串
     */
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }

    /**
     * 將Base64編碼後的公鑰轉換成 PublicKey 物件
     * @param pubStr
     * @return PublicKey
     */
    public static PublicKey string2PublicKey(String pubStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 將Base64編碼後的私鑰轉換成 PrivateKey 物件
     * @param priStr
     * @return PrivateKey
     */
    public static PrivateKey string2Privatekey(String priStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 公鑰加密
     * @param content 待加密的內容 byte[]
     * @param publicKey 加密所需的公鑰物件 PublicKey
     * @return 加密後的位元組陣列 byte[]
     */
    public static byte[] publicEncrytype(byte[] content, PublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }

    /**
     * 私鑰解密
     * @param content   待解密的內容 byte[]
     * @param privateKey    解密需要的私鑰物件 PrivateKey
     * @return 解密後的位元組陣列 byte[]
     */
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
}

測試：

AESUtilTest

package com.fknight.sbsmdemo.tools;

import javax.crypto.SecretKey;
import java.util.Base64;

/**
 * 測試 AESUtil 對AES加密演算法的封裝
 */
public class AESUtilTest {
    public static void main(String[] args){
        String content = "abcdefg789+-*+="; // 待加密的字串
        System.out.println("明文資料為：" + content);
        try {
            // 獲得經 BASE64 處理之後的 AES 金鑰
            String strKeyAES = AESUtil.getStrKeyAES();
            System.out.println("經BASE64處理之後的金鑰：" + strKeyAES);

            // 將 BASE64 處理之後的 AES 金鑰轉為 SecretKey
            SecretKey secretKey = AESUtil.strKey2SecretKey(strKeyAES);

            // 加密資料
            byte[] encryptAESbytes = AESUtil.encryptAES(content.getBytes("utf-8"), secretKey);
            System.out.println("加密後的資料經 BASE64 處理之後為：" + Base64.getEncoder().encodeToString(encryptAESbytes));
            // 解密資料
            String decryptAESStr = new String(AESUtil.decryptAES(encryptAESbytes, secretKey), "utf-8");
            System.out.println("解密後的資料為：" + decryptAESStr);

            if (content.equals(decryptAESStr)){
                System.out.println("測試通過！");
            }else {
                System.out.println("測試未通過！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

測試結果：

RSAUtilTest

package com.fknight.sbsmdemo.tools;

import java.security.*;
import java.util.Base64;

/**
 * 對 RSAUtil 進行測試
 */
public class RSAUtilTest {

    public static void main(String[] args){
        String content = "abcdefg456+-=";   // 明文內容
        System.out.println("原始字串是：" + content);
        try {
            // 獲得金鑰對
            KeyPair keyPair =  RSAUtil.getKeyPair();
            // 獲得進行Base64 加密後的公鑰和私鑰 String
            String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
            String publicKeyStr = RSAUtil.getPublicKey(keyPair);
            System.out.println("Base64處理後的私鑰：" + privateKeyStr + "\n"
                + "Base64處理後的公鑰：" + publicKeyStr);

            // 獲得原始的公鑰和私鑰，並以字串形式列印出來
            PrivateKey privateKey = RSAUtil.string2Privatekey(privateKeyStr);
            PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStr);

            // 公鑰加密/私鑰解密
            byte[] publicEncryBytes =  RSAUtil.publicEncrytype(content.getBytes(), publicKey);
            System.out.println("公鑰加密後的字串(經BASE64處理)：" + Base64.getEncoder().encodeToString(publicEncryBytes));
            byte[] privateDecryBytes = RSAUtil.privateDecrypt(publicEncryBytes, privateKey);
            System.out.println("私鑰解密後的原始字串：" + new String(privateDecryBytes));

            String privateDecryStr = new String(privateDecryBytes, "utf-8");
            if (content.equals(privateDecryStr)){
                System.out.println("測試通過！");
            }else {
                System.out.println("測試未通過！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

測試結果：

PS：關於如何使用 JavaScript 和 Java 進行跨語言 AES 和 RSA 的實現可以參考我的另一篇博文

https://blog.csdn.net/gulang03/article/details/82230408

相關文章