El siguiente es un código de muestra de la clase RSAUtil que usa Spring Boot para implementar el cifrado, descifrado, firma y verificación de RSA:
```
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;
}
}
```Esta clase tiene cinco métodos estáticos:
- `generateKeyPair()`
: este método se usa para generar un par de claves pública-privada RSA, y el valor devuelto es un mapa que contiene la clave pública-privada.
- `cifrar(Cadena de datos, Cadena publicKeyString)`：
Este método se utiliza para cifrar datos mediante la clave pública y devolver la cadena cifrada codificada en Base64.
- `descifrar (Cadena de datos cifrados, Cadena de cadena de clave privada)`：
Este método se utiliza para descifrar los datos cifrados mediante la clave privada y devolver la cadena descifrada.
- `firmar(Cadena de datos, Cadena privateKeyString)`：
Este método se utiliza para firmar los datos con la clave privada y devolver la cadena codificada en Base64 firmada.
- `verificar(datos de cadena, firma de cadena, cadena publicKeyString)`：
Este método se usa para verificar la firma usando la clave pública y devuelve verdadero si la verificación pasa; de lo contrario, devuelve falso.
Además, esta clase también tiene un método estático `sortParams(Map<String, String> params)`, que se usa para ordenar los parámetros en el Mapa y devolver la cadena ordenada para usarla en la firma.
Aquí hay un ejemplo de uso:
```
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);
}
```Este código de muestra usa primero el método `generateKeyPair()` para generar un par de claves pública-privada RSA, y almacena la clave pública-privada en las variables `publicKey` y `privateKey`. Luego, usa el método `encrypt()` para cifrar la cadena "¡Hola, mundo!", y luego usa el método `decrypt()` para descifrar los datos cifrados, y finalmente genera la cadena antes y después del cifrado y la cadena después del descifrado. Luego, usa el método `sortParams()` para ordenar un mapa que contiene tres parámetros, luego usa el método `sign()` para firmar los parámetros ordenados y usa el método `verify()` para verificar la firma. Finalmente, genera los parámetros ordenados, el resultado de la firma y el resultado de la verificación de la firma.
Espero que este ejemplo pueda ayudarlo a satisfacer sus necesidades.