常用加密算法之 RSA 简介及应用

news2025/1/11 15:06:14

引言

一、RSA算法简介

RSA （Rivest-Shamir-Adleman） 算法是一种非对称加密技术，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年发明。它基于大数质因数分解的困难性，提供了一种安全的数据加密和解密方法。

1. 密钥生成

RSA算法使用一对公钥和私钥：

公钥：用于加密数据，可以公开分享。
私钥：用于解密数据，必须严格保密。
密钥生成过程包括选择两个大素数，计算它们的乘积，并基于此生成公钥和私钥。

2. 加密与解密

加密：使用公钥对数据进行加密。
解密：使用私钥对加密后的数据进行解密。

二、RSA 在 Spring Boot 中的应用

1. 数据安全传输

在Spring Boot应用中，RSA可以用于加密敏感数据，如用户密码、支付信息等，确保数据在传输过程中的安全性。

2. API安全

通过使用RSA算法对API请求和响应进行加密，可以有效防止数据在网络传输过程中被截获和篡改。

3. 数字签名

利用RSA的数字签名功能，Spring Boot应用可以验证数据的完整性和来源，防止数据被篡改。

4. 集成第三方服务

在与第三方服务集成时，如支付网关或身份验证服务，RSA算法常用于安全地交换密钥和数据。

在这里插入图片描述

三、实现RSA加密的步骤

1. 添加依赖

在Spring Boo t项目的 pom.xml 文件中添加相关依赖，如 bcprov-jdk15on 用于提供Java加密架构的实现。

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-jdk15on</artifactId>
    <version>1.69</version>
</dependency>

2. 生成密钥对

使用Java的KeyPairGenerator生成RSA密钥对，并存储公钥和私钥。

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(2048);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

3. 加密和解密

使用公钥进行数据加密，使用私钥进行数据解密。

Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes());

// 解密
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedData = cipher.doFinal(encryptedData);

4. 安全性增强：使用RSA加密AES密钥 (推荐)

为了进一步提高安全性，可以使用RSA来加密AES的密钥（对称加密的密钥），然后用AES来加密实际的数据。

客户端首先生成一个随机的AES密钥，并使用RSA公钥加密这个AES密钥。
客户端然后使用AES密钥加密要发送的数据，并将加密后的AES密钥和加密后的数据一起发送给服务器。
服务器收到后，首先使用RSA私钥解密AES密钥，然后使用解密后的AES密钥来解密数据。

四、RSA 加密示例

import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RSAExample {

    // 生成密钥对
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048); // 设置密钥长度为2048位
        return keyPairGenerator.generateKeyPair();
    }

    // 将私钥转换为字符串形式以便存储
    public static String privateKeyToString(PrivateKey privateKey) {
        byte[] encoded = privateKey.getEncoded();
        return Base64.getEncoder().encodeToString(encoded);
    }

    // 从字符串形式恢复私钥
    public static PrivateKey stringToPrivateKey(String privateKeyStr) throws GeneralSecurityException {
        byte[] encoded = Base64.getDecoder().decode(privateKeyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encoded);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(keySpec);
    }

    // 将公钥转换为字符串形式以便存储
    public static String publicKeyToString(PublicKey publicKey) {
        byte[] encoded = publicKey.getEncoded();
        return Base64.getEncoder().encodeToString(encoded);
    }

    // 从字符串形式恢复公钥
    public static PublicKey stringToPublicKey(String publicKeyStr) throws GeneralSecurityException {
        byte[] encoded = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(encoded);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePublic(keySpec);
    }

    // 使用公钥加密数据
    public static byte[] encrypt(PublicKey publicKey, byte[] data) throws GeneralSecurityException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }

    // 使用私钥解密数据
    public static byte[] decrypt(PrivateKey privateKey, byte[] encryptedData) throws GeneralSecurityException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(encryptedData);
    }

    public static void main(String[] args) {
        try {
            // 生成密钥对
            KeyPair keyPair = generateKeyPair();
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();

            // 将密钥转换为字符串并打印
            String publicKeyStr = publicKeyToString(publicKey);
            String privateKeyStr = privateKeyToString(privateKey);
            System.out.println("公钥: " + publicKeyStr);
            System.out.println("私钥: " + privateKeyStr);

            // 模拟加密和解密过程
            String originalMessage = "这是一个需要加密的消息";
            System.out.println("原始消息: " + originalMessage);

            // 加密
            byte[] encryptedData = encrypt(publicKey, originalMessage.getBytes());
            System.out.println("加密后的数据: " + Base64.getEncoder().encodeToString(encryptedData));

            // 解密
            PrivateKey restoredPrivateKey = stringToPrivateKey(privateKeyStr);
            byte[] decryptedData = decrypt(restoredPrivateKey, encryptedData);
            System.out.println("解密后的消息: " + new String(decryptedData));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}