package com.ruoyi.common.utils;
|
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Component;
|
|
import javax.crypto.Cipher;
|
import java.io.UnsupportedEncodingException;
|
import java.net.URLDecoder;
|
import java.net.URLEncoder;
|
import java.nio.charset.StandardCharsets;
|
import java.security.KeyFactory;
|
import java.security.PrivateKey;
|
import java.security.PublicKey;
|
import java.security.spec.PKCS8EncodedKeySpec;
|
import java.security.spec.X509EncodedKeySpec;
|
import java.util.Base64;
|
|
@Slf4j
|
@Component
|
public class RSAPublicKeyExample {
|
|
//
|
// /**
|
// * 数据解密
|
// *
|
// * @param encryptedData
|
// * @return
|
// */
|
// public String decryptedData(String encryptedData, String pri_key) {
|
// String privateKeyString = "私钥的Base64编码字符串"; // 后端私钥的Base64编码字符串
|
//
|
// try {
|
// // 将私钥Base64编码字符串转换为PrivateKey对象
|
// byte[] privateKeyBytes = Base64.getDecoder().decode(pri_key);
|
// PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
|
// KeyFactory keyFactory = KeyFactory.getInstance("RSA");
|
// PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
|
//
|
// // 使用私钥解密数据
|
// Cipher decryptCipher = Cipher.getInstance("RSA");
|
// decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
|
// byte[] decryptedBytes = decryptCipher.doFinal(Base64.getDecoder().decode(encryptedData));
|
//
|
// // 解密后的数据
|
// String decryptedData = new String(decryptedBytes);
|
// System.out.println("解密后的数据：" + decryptedData);
|
// return decryptedData;
|
// } catch (Exception e) {
|
// log.error("解密报错了:{}", e.getMessage());
|
// }
|
// return null;
|
// }
|
//
|
// /**
|
// * 要加密的明文数据
|
// *
|
// * @param plainText
|
// * @return
|
// */
|
// public String encryptedData(String plainText, String pub_key) {
|
// log.info("需要加密的数据：{}", plainText);
|
// try {
|
//
|
// byte[] publicKeyBytes = Base64.getDecoder().decode(pub_key);
|
// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
|
// KeyFactory keyFactory = KeyFactory.getInstance("RSA");
|
// PublicKey publicKey = keyFactory.generatePublic(keySpec);
|
//
|
// // 使用公钥加密数据
|
// Cipher encryptCipher = Cipher.getInstance("RSA");
|
// encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);
|
// byte[] encryptedBytes = encryptCipher.doFinal(plainText.getBytes());
|
//
|
// // 将加密后的数据转换为Base64编码的字符串
|
// String encryptedText = Base64.getEncoder().encodeToString(encryptedBytes);
|
// log.info("Base64加密后的数据：{}", encryptedText);
|
// encryptedText = URLEncoder.encode(encryptedText, StandardCharsets.UTF_8.toString());
|
// log.info("URLEncoder编码后的数据：{}", encryptedText);
|
// String decodedString = URLDecoder.decode(encryptedText, "UTF-8");
|
// log.info("URLEncoder解码后的数据：{}", decodedString);
|
// return encryptedText;
|
// } catch (Exception e) {
|
// log.error("加密失败了:{}", e.getMessage());
|
// }
|
// return null;
|
// }
|
|
/**
|
* 要加密的明文数据
|
*
|
* @param plainText
|
* @return
|
*/
|
public String encryptedData(String plainText, String pub_key) {
|
try {
|
byte[] publicKeyBytes = Base64.getDecoder().decode(pub_key);
|
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
|
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
|
PublicKey publicKey = keyFactory.generatePublic(keySpec);
|
|
// 使用公钥加密数据
|
Cipher encryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
|
encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey);
|
byte[] encryptedBytes = encryptCipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
|
|
// URL Safe Base64 编码
|
return Base64.getUrlEncoder().encodeToString(encryptedBytes);
|
} catch (Exception e) {
|
log.error("加密失败: {}", e.getMessage());
|
}
|
return null;
|
}
|
|
/**
|
* 数据解密
|
*
|
* @param encryptedData
|
* @return
|
*/
|
public String decryptedData(String encryptedData, String pri_key) {
|
try {
|
// 将私钥Base64编码字符串转换为PrivateKey对象
|
byte[] privateKeyBytes = Base64.getDecoder().decode(pri_key);
|
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
|
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
|
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
|
|
// URL Safe Base64 解码
|
byte[] cipherBytes = Base64.getUrlDecoder().decode(encryptedData);
|
|
// 使用私钥解密数据
|
Cipher decryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
|
decryptCipher.init(Cipher.DECRYPT_MODE, privateKey);
|
byte[] decryptedBytes = decryptCipher.doFinal(cipherBytes);
|
|
return new String(decryptedBytes, StandardCharsets.UTF_8);
|
} catch (Exception e) {
|
log.error("解密失败: {}", e.getMessage());
|
}
|
return null;
|
}
|
|
public static void main(String[] args) {
|
String decodedString = null;
|
try {
|
decodedString = URLDecoder.decode("0902%E4%BB%BB%E5%8A%A1%E6%B5%8B%E8%AF%95--------", "UTF-8");
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
System.out.println(decodedString);
|
}
|
|
}
|
