以下是一个使用Spring Boot实现RSA加密、解密、签名和验签的RSAUtil类的示例代码：
```
import org.springframework.util.Base64Utils;
import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;
public class RSAUtil {
private static final String RSA_ALGORITHM = "RSA";
//这个函数是自己随机生成一个rsa的公私密钥对，一般情况下我们是从配置文件或者redis读取密钥对的，也就是这个函数用不到。
public static Map<String, String> generateKeyPair() throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
keyPairGenerator.initialize(2048);//2048太长了，一般1024即可
KeyPair keyPair = keyPairGenerator.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
String publicKeyString = Base64Utils.encodeToString(publicKey.getEncoded());
String privateKeyString = Base64Utils.encodeToString(privateKey.getEncoded());
return Map.of("publicKey", publicKeyString, "privateKey", privateKeyString);
//这里map.of如果用不了，就老老实实new个map.put去加载<k，v>
}
public static String encrypt(String data, String publicKeyString) throws Exception {
byte[] publicKeyBytes = Base64Utils.decodeFromString(publicKeyString);
PublicKey publicKey = KeyFactory.getInstance(RSA_ALGORITHM).generatePublic(new X509EncodedKeySpec(publicKeyBytes));
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedBytes = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
return Base64Utils.encodeToString(encryptedBytes);
}
public static String decrypt(String encryptedData, String privateKeyString) throws Exception {
byte[] privateKeyBytes = Base64Utils.decodeFromString(privateKeyString);
PrivateKey privateKey = KeyFactory.getInstance(RSA_ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedBytes = cipher.doFinal(Base64Utils.decodeFromString(encryptedData));
return new String(decryptedBytes, StandardCharsets.UTF_8);
}
public static String sign(String data, String privateKeyString) throws Exception {
byte[] privateKeyBytes = Base64Utils.decodeFromString(privateKeyString);
PrivateKey privateKey = KeyFactory.getInstance(RSA_ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
Signature signature = Signature.getInstance("SHA256withRSA");
signature.initSign(privateKey);
signature.update(data.getBytes(StandardCharsets.UTF_8));
byte[] signatureBytes = signature.sign();
return Base64Utils.encodeToString(signatureBytes);
}
public static boolean verify(String data, String signature, String publicKeyString) throws Exception {
byte[] publicKeyBytes = Base64Utils.decodeFromString(publicKeyString);
PublicKey publicKey = KeyFactory.getInstance(RSA_ALGORITHM).generatePublic(new X509EncodedKeySpec(publicKeyBytes));
Signature verifier = Signature.getInstance("SHA256withRSA");
verifier.initVerify(publicKey);
verifier.update(data.getBytes(StandardCharsets.UTF_8));
byte[] signatureBytes = Base64Utils.decodeFromString(signature);
return verifier.verify(signatureBytes);
}
public static String sortParams(Map<String, String> params) {
String[] keys = params.keySet().toArray(new String[0]);
Arrays.sort(keys);
String sortedParams = Arrays.stream(keys)
.map(key -> key + "=" + params.get(key))
.collect(Collectors.joining("&"));
return sortedParams;
}
}
```这个类有五个静态方法：
- `generateKeyPair()`
- 该方法用于生成RSA公私密钥对，返回值是一个包含公私钥的Map。
- `encrypt(String data, String publicKeyString)`：
该方法用于使用公钥对数据进行加密，并返回加密后的Base64编码字符串。
- `decrypt(String encryptedData, String privateKeyString)`：
该方法用于使用私钥对加密后的数据进行解密，并返回解密后的字符串。
- `sign(String data, String privateKeyString)`：
该方法用于使用私钥对数据进行签名，并返回签名后的Base64编码字符串。
- `verify(String data, String signature, String publicKeyString)`：
该方法用于使用公钥对签名进行验证，如果验证通过则返回true，否则返回false。
此外，该类还有一个静态方法`sortParams(Map<String, String> params)`，该方法用于对Map中的参数进行排序，并返回排序后的字符串，供签名时使用。
下面是一个使用示例：
```
public static void main(String[] args) throws Exception {
// 生成公私密钥对，或者不生成，直接从配置文件载入pub&pri的2个字符串值
Map<String, String> keyPair = RSAUtil.generateKeyPair();
String publicKey = keyPair.get("publicKey");
String privateKey = keyPair.get("privateKey");
// 加密解密示例
String data = "Hello, world!";
String encryptedData = RSAUtil.encrypt(data, publicKey);
String decryptedData = RSAUtil.decrypt(encryptedData, privateKey);
System.out.println("原始数据：" + data);
System.out.println("加密后数据：" + encryptedData);
System.out.println("解密后数据：" + decryptedData);
// 签名验签示例，Map.of可以改成new map.put(k,v)
Map<String, String> params = Map.of(
"timestamp", "1621005751",
"nonce", "123456",
"data", "Hello, world!"
);
String sortedParams = RSAUtil.sortParams(params);
String signature = RSAUtil.sign(sortedParams, privateKey);
boolean verified = RSAUtil.verify(sortedParams, signature, publicKey);
System.out.println("排序后的参数：" + sortedParams);
System.out.println("签名结果：" + signature);
System.out.println("验签结果：" + verified);
}
```这个示例代码首先使用`generateKeyPair()`方法生成一个RSA公私密钥对，并将公私钥存储在变量`publicKey`和`privateKey`中。然后，它使用`encrypt()`方法将字符串"Hello, world!"加密，然后使用`decrypt()`方法对加密后的数据进行解密，最后输出加密前后的字符串和解密后的字符串。接下来，它使用`sortParams()`方法将一个包含三个参数的Map进行排序，然后使用`sign()`方法对排序后的参数进行签名，并使用`verify()`方法对签名进行验证。最后，它输出排序后的参数、签名结果和验签结果。
希望这个示例能够帮助你实现你的需求。