Java RSA加密工具類的設(shè)計與實現(xiàn)詳解

更新時間：2025年02月09日 09:43:34 作者：子非衣

RSA算法是一種常用的非對稱加密算法,這篇文章主要為大家詳細介紹了如何通過Java編寫一個RSA加密工具類,感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下

RSA算法是一種常用的非對稱加密算法，它具有以下主要特點：

1.非對稱性：RSA 使用一對密鑰——公鑰和私鑰。公鑰用于加密，私鑰用于解密，也可以反過來使用私鑰簽名、公鑰驗證。相對于對稱加密的單一密鑰，非對稱性提高了安全性。

2.安全性高：RSA 的安全性依賴于大整數(shù)分解的數(shù)學(xué)難題。當(dāng)前計算能力下，分解足夠大的整數(shù)非常困難，因此 RSA 算法在合理的密鑰長度下非常安全（通常建議使用 2048 位或更高的密鑰長度）。

3.密鑰長度可調(diào)：RSA 算法的密鑰長度通常為 1024、2048 或 4096 位。密鑰長度越長，安全性越高，但計算速度越慢。

4.加密與簽名：RSA 不僅可以用于加密，還可以用于數(shù)字簽名。用私鑰簽名的消息可以用公鑰驗證，確保消息的完整性和真實性，特別適合身份認證等場景。

5.加密速度較慢：與對稱加密算法（如 AES）相比，RSA 的加密和解密速度較慢，因此它一般用于加密小數(shù)據(jù)或加密對稱密鑰（例如在 TLS/SSL 中），然后使用對稱加密算法進行數(shù)據(jù)傳輸。

6.不可逆性：使用公鑰加密的數(shù)據(jù)只能通過對應(yīng)的私鑰解密，私鑰加密（簽名）也只能用公鑰驗證，保障了數(shù)據(jù)安全傳輸。

7.抗碰撞性：因為密鑰的唯一性和大整數(shù)分解的困難，RSA 很難被偽造或碰撞。即使加密內(nèi)容和公鑰被獲取，攻擊者也很難推導(dǎo)出私鑰。

RSA的典型應(yīng)用場景

1.安全數(shù)據(jù)傳輸：如 SSL/TLS 協(xié)議中，用于安全地傳輸加密的對稱密鑰。

2.身份驗證和授權(quán)：如數(shù)字簽名、電子簽名中，保障簽名的真實性和防篡改性。

3.數(shù)字證書：數(shù)字證書（如 HTTPS 中的證書）使用 RSA來提供加密和驗證身份。

RSA 由于其高安全性和可靠性，廣泛用于現(xiàn)代網(wǎng)絡(luò)安全通信中。

直接上代碼

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

/**
 * @author Sakura
 * @date 2024/11/11 11:11
 */
public class RSAUtil {

    // 定義密鑰長度
    private static final int KEY_SIZE = 2048;
    private static final String ALGORITHM = "RSA";

    /**
     * 生成RSA密鑰對
     * @return KeyPair 包含公鑰和私鑰
     * @throws Exception 如果生成失敗
     */
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 使用公鑰加密
     * @param data 待加密的數(shù)據(jù)
     * @param publicKeyStr Base64編碼的公鑰字符串
     * @return 加密后的數(shù)據(jù)（Base64編碼）
     * @throws Exception 如果加密失敗
     */
    public static String encrypt(String data, String publicKeyStr) throws Exception {
        PublicKey publicKey = getPublicKeyFromBase64(publicKeyStr);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    /**
     * 使用私鑰解密
     * @param encryptedData Base64編碼的加密數(shù)據(jù)
     * @param privateKeyStr Base64編碼的私鑰字符串
     * @return 解密后的數(shù)據(jù)
     * @throws Exception 如果解密失敗
     */
    public static String decrypt(String encryptedData, String privateKeyStr) throws Exception {
        PrivateKey privateKey = getPrivateKeyFromBase64(privateKeyStr);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedData = cipher.doFinal(decodedData);
        return new String(decryptedData);
    }

    /**
     * 將Base64編碼的公鑰字符串轉(zhuǎn)換為PublicKey對象
     * @param publicKeyStr Base64編碼的公鑰字符串
     * @return PublicKey對象
     * @throws Exception 如果轉(zhuǎn)換失敗
     */
    public static PublicKey getPublicKeyFromBase64(String publicKeyStr) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * 將Base64編碼的私鑰字符串轉(zhuǎn)換為PrivateKey對象
     * @param privateKeyStr Base64編碼的私鑰字符串
     * @return PrivateKey對象
     * @throws Exception 如果轉(zhuǎn)換失敗
     */
    public static PrivateKey getPrivateKeyFromBase64(String privateKeyStr) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 將PublicKey對象轉(zhuǎn)換為Base64編碼的字符串
     * @param publicKey PublicKey對象
     * @return Base64編碼的公鑰字符串
     */
    public static String encodePublicKeyToBase64(PublicKey publicKey) {
        return Base64.getEncoder().encodeToString(publicKey.getEncoded());
    }

    /**
     * 將PrivateKey對象轉(zhuǎn)換為Base64編碼的字符串
     * @param privateKey PrivateKey對象
     * @return Base64編碼的私鑰字符串
     */
    public static String encodePrivateKeyToBase64(PrivateKey privateKey) {
        return Base64.getEncoder().encodeToString(privateKey.getEncoded());
    }

    /**
     * 從 RSA 私鑰計算出對應(yīng)的公鑰
     * @param privateKey RSA 私鑰對象
     * @return PublicKey 對象
     * @throws Exception 如果轉(zhuǎn)換失敗
     */
    public static PublicKey getPublicKeyFromPrivateKey(PrivateKey privateKey) throws Exception {
        // 檢查私鑰類型是否為 RSA 私鑰
        if (!(privateKey instanceof RSAPrivateKey)) {
            throw new IllegalArgumentException("The provided key is not an RSA private key.");
        }

        // 從私鑰中提取模數(shù)和私鑰指數(shù)
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
        java.math.BigInteger modulus = rsaPrivateKey.getModulus();
        java.math.BigInteger publicExponent = java.math.BigInteger.valueOf(65537); // 常用的公鑰指數(shù)

        // 使用模數(shù)和公鑰指數(shù)構(gòu)造公鑰規(guī)范
        RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(modulus, publicExponent);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

        // 根據(jù)規(guī)范生成公鑰
        return keyFactory.generatePublic(publicKeySpec);
    }

    public static void main(String[] args) throws Exception {
        // 生成私鑰和公鑰
//        KeyPair keyPair = generateKeyPair();
//        String publicKeyStr = encodePublicKeyToBase64(keyPair.getPublic());
//        String privateKeyStr = encodePrivateKeyToBase64(keyPair.getPrivate());
//        System.out.println(publicKeyStr);
//        System.out.println(privateKeyStr);

        // 公鑰對外暴露加密用
        String publicKeyStr = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuggI4MbASTLHkTbqn6kKIDSKqFKMkiqVymD6DnY5Rcx9U8X97pjK/0pgRvu1xKs4S8Zwo6dgRxjX9Tzao/2OsxjJBIecj6iX47nx7vz6W30G7D+fOu5pNd9iqtu99tcNx+jen5vgqda5NmDHO4sg0oQsNqUy4+jTx+QeU5x0NesvGHO8A+dEKAbDGpyak6MH7X7N9CWTyRyLlmh0jqqc2zs0pkUJsHqtBO7EkPsmI82pSbCIPWmviBN1Z4OXz0bUJdgs2785O+91E00EP0Ktnsvgqg6rKJ2LA7EZczMpcipkCcxjEYMnU+TIIrkXiJX/QrLoOnwJNqUPxfy6haNDcwIDAQAB";
        // 私鑰服務(wù)器保留解密用
        String privateKeyStr = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC6CAjgxsBJMseRNuqfqQogNIqoUoySKpXKYPoOdjlFzH1Txf3umMr/SmBG+7XEqzhLxnCjp2BHGNf1PNqj/Y6zGMkEh5yPqJfjufHu/PpbfQbsP5867mk132Kq27321w3H6N6fm+Cp1rk2YMc7iyDShCw2pTLj6NPH5B5TnHQ16y8Yc7wD50QoBsManJqTowftfs30JZPJHIuWaHSOqpzbOzSmRQmweq0E7sSQ+yYjzalJsIg9aa+IE3Vng5fPRtQl2Czbvzk773UTTQQ/Qq2ey+CqDqsonYsDsRlzMylyKmQJzGMRgydT5MgiuReIlf9Csug6fAk2pQ/F/LqFo0NzAgMBAAECggEAFVt+yW+H+99ckgtf/FyH0RK3KIPxp4ZEFCv2CVsBUEYdzVRZxt67z3tWek/DmoSdvfVWUTOSFheAE6Oc5l7h1yXtThvTmZqddYOPhwR8Kay88rqLKVTdt1WiGkOIF6Kw7laJ2IEo1dbVBK0vsmJSrliGSu/EW+4LAlPqN2cq4FWhtIA5yV3VUuScV9/rI9jvYiwP2ltVUs92Mbkj8AHOpMR+ZrijJupXoWldLSFA91BitKSAZga2xkLRMWeT1TNwhMEU4ihZTJBfFICuGDxzdUXWGXqm8lvMR0bSuerIiXRYspQ/DyobfEfggI+lYeLscp7DtGu0DwMlvrTdNkS2AQKBgQDkwgZ6EGWKVu3Qu3kYLt6gGtqxcUBfbdZyvJFRTxDda5RIFUn3NUDwXNMzB+bZpR4G42P6oVQON8BtMu3tNCUr/97oiTfEMrkkiIRzCVDOrmmrXtmus6rmcDKChlZrfb5TzoHa1borEEFRV7QCoA1ChEkxEMJoL7P39tQ8BqCnMwKBgQDQL2/m2PsIl7wEl5xC+uFrqfd4bl9Ljmt9Ywy0J1DYY/obrtGifPGnkePRAh+o4s7eP2brtBFiRG3/fNOMgHsmk501g3t/wbQ3m0JsKTN6/AtDVcwKTe4ysZpJDVaaJygTzoRRZ/opo77LBc8e7WxZedixM9EFgtFbQCqsqa3ywQKBgEO/Vo2152yF/B5SNzW7Q8Fk0pm0cZ0ReW43fE35PYRlxN9oNqSYx+enhgDZ+TtB1Fez5jsmpi8jwcBVUfNq+wtB1vFFGhfn8b7pE1jCTIU5UCApkgxUN2vRlJPlVxi0f7ZwNTLrExyHzuBZOf2BCwxFAywdy4VxgzoPhqFUUSXTAoGAQelS52Z5C/5mM5oAiiA98EVOqV1gZF6B35/VbNApw2jbzZnqmyQtqh0BYLHobiLo1eqC3ksTWeZKYSIXJBulYdBIbKHlHsyoDxbjz7S3rM9RjY8DW5vSt1ANheVoLsQI50RyFgfyZu6FwGdlbOhEbouqNGgwXCtPtzE4kZPjE8ECgYEA0LY49wpA3UQc8d2PEhTleRhNkpBGbV+wBDrJOlVoxIrTzFsk00vnPGf4OCwIEagxxmdI51dgXgq0BHU/ry3t1fAI1y3YL0WLJxuTQpS0iETcwL/gYkgGLRASm9cswRy+NEKx0l5shMT/0Ow8ntFrdRYOkfGtLIDlXx4LezhsUaY=";
        // 帶加密密碼
        String password = "123456";

        // 加密后字符串
        String str = encrypt(password, publicKeyStr);
        System.out.println(str);
        // 解密字符串
        String str1 = decrypt(str, privateKeyStr);
        System.out.println(str1);

        // 如果只知道私鑰計算公鑰
        PublicKey publicKeyFromPrivate = RSAUtil.getPublicKeyFromPrivateKey(getPrivateKeyFromBase64(privateKeyStr));

        // 打印公鑰
        System.out.println(Base64.getEncoder().encodeToString(publicKeyFromPrivate.getEncoded()));


    }
}

我們可以通過下面的方法生成密鑰對

我們用生成的密鑰對測試一下，可以看到能正常加解密以及通過私鑰計算公鑰

這里有一點要注意，盡管我們每次都使用同一個公鑰進行加密，但是得到的加密字符串是不一樣的，這是因為在 RSA 加密中，特別是使用 PKCS#1 v1.5 填充模式（即 RSA/ECB/PKCS1Padding），PKCS#1 v1.5 會在加密前對明文進行特定的隨機填充，確保每次加密結(jié)果不同。

下面是 RSA2 的（注意使用了"RSA/ECB/OAEPWithSHA-256AndMGF1Padding"填充，所以需要對接方也需要使用相同的填充方式才可以）

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

/**
 * @author Sakura
 * @date 2024/12/6 19:10
 */
public class RSA2Util {

    // 定義密鑰長度
    private static final int KEY_SIZE = 1024; // 1024 2048 長度越大越安全但是數(shù)據(jù)長度越長
    private static final String ALGORITHM = "RSA";

    /**
     * 生成RSA密鑰對
     *
     * @return KeyPair 包含公鑰和私鑰
     * @throws Exception 如果生成失敗
     */
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 使用公鑰加密
     *
     * @param data         待加密的數(shù)據(jù)
     * @param publicKeyStr Base64編碼的公鑰字符串
     * @return 加密后的數(shù)據(jù)（Base64編碼）
     * @throws Exception 如果加密失敗
     */
    public static String encrypt(String data, String publicKeyStr) throws Exception {
        PublicKey publicKey = getPublicKeyFromBase64(publicKeyStr);
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedData);
    }

    /**
     * 使用私鑰解密
     *
     * @param encryptedData Base64編碼的加密數(shù)據(jù)
     * @param privateKeyStr Base64編碼的私鑰字符串
     * @return 解密后的數(shù)據(jù)
     * @throws Exception 如果解密失敗
     */
    public static String decrypt(String encryptedData, String privateKeyStr) throws Exception {
        PrivateKey privateKey = getPrivateKeyFromBase64(privateKeyStr);
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedData = cipher.doFinal(decodedData);
        return new String(decryptedData);
    }

    /**
     * 使用私鑰對數(shù)據(jù)進行簽名（SHA256withRSA）
     *
     * @param data         待簽名的數(shù)據(jù)
     * @param privateKeyStr Base64編碼的私鑰字符串
     * @return 簽名后的數(shù)據(jù)（Base64編碼）
     * @throws Exception 如果簽名失敗
     */
    public static String sign(String data, String privateKeyStr) throws Exception {
        PrivateKey privateKey = getPrivateKeyFromBase64(privateKeyStr);
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);
        signature.update(data.getBytes());
        byte[] signedData = signature.sign();
        return Base64.getEncoder().encodeToString(signedData);
    }

    /**
     * 使用公鑰驗證簽名（SHA256withRSA）
     *
     * @param data         原始數(shù)據(jù)
     * @param signedData   Base64編碼的簽名數(shù)據(jù)
     * @param publicKeyStr Base64編碼的公鑰字符串
     * @return 驗簽結(jié)果，true為簽名有效
     * @throws Exception 如果驗證失敗
     */
    public static boolean verify(String data, String signedData, String publicKeyStr) throws Exception {
        PublicKey publicKey = getPublicKeyFromBase64(publicKeyStr);
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initVerify(publicKey);
        signature.update(data.getBytes());
        byte[] decodedSignedData = Base64.getDecoder().decode(signedData);
        return signature.verify(decodedSignedData);
    }

    public static PublicKey getPublicKeyFromBase64(String publicKeyStr) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(keySpec);
    }

    public static PrivateKey getPrivateKeyFromBase64(String privateKeyStr) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(keySpec);
    }

    public static String encodePublicKeyToBase64(PublicKey publicKey) {
        return Base64.getEncoder().encodeToString(publicKey.getEncoded());
    }

    public static String encodePrivateKeyToBase64(PrivateKey privateKey) {
        return Base64.getEncoder().encodeToString(privateKey.getEncoded());
    }

    public static void main(String[] args) throws Exception {
        // 生成私鑰和公鑰
        KeyPair keyPair = generateKeyPair();
        String publicKeyStr = encodePublicKeyToBase64(keyPair.getPublic());
        String privateKeyStr = encodePrivateKeyToBase64(keyPair.getPrivate());

        System.out.println("公鑰: " + publicKeyStr);
        System.out.println("私鑰: " + privateKeyStr);

        // 測試加密解密
        String data = "qaz123456.";
        String encryptedData = encrypt(data, publicKeyStr);
        System.out.println("加密后: " + encryptedData);
        String decryptedData = decrypt(encryptedData, privateKeyStr);
        System.out.println("解密后: " + decryptedData);

        // 測試簽名和驗簽
        String signature = sign(data, privateKeyStr);
        System.out.println("簽名: " + signature);
        boolean isVerified = verify(data, signature, publicKeyStr);
        System.out.println("驗簽結(jié)果: " + isVerified);
    }
}

到此這篇關(guān)于Java RSA加密工具類的設(shè)計與實現(xiàn)詳解的文章就介紹到這了,更多相關(guān)Java RSA加密工具類內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: