Java rsa加解密工具类
RsaUtil.java
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
/**
* <h2>非对称Rsa加解密工具</h2>
* <p>
* 可以固定公钥私钥，也可以将公钥私钥生成出来，给予前端使用
* </p>
*
* @author Evan <[email protected]>
*
*/
public class RsaUtil {
private RsaUtil(){
}
public static final String KEY_ALGORITHM = "RSA";
private static final String PUBLIC_KEY = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKYAav5NQz+peuSObG5e6JTF7gtJAV/hbW28uz/GirbhIGzloHxZVP/VyA+Xsvvz48h2dVs6llgCO6j5g72g9KsCAwEAAQ==";
private static final String PRIVATE_KEY = "MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEApgBq/k1DP6l65I5sbl7olMXuC0kBX+Ftbby7P8aKtuEgbOWgfFlU/9XID5ey+/PjyHZ1WzqWWAI7qPmDvaD0qwIDAQABAkA1Ui8L7k9qlIrX/XOQ5EV6/DThRRr+7E8VD6lp6+FEqnjp29HMnPTto1GuKWnkmzilyWbpXoGbscoZ62Koj6UZAiEA22nFpyqOh7sTmohwaYZHyHJwNGYq4TaayndDqNfpkHcCIQDBrqJIVgb0lv/88GrdWUAzHE7YmEfLSQggjvqYBmOebQIhAJMeNehjkZQS7Q8V4wHuhp0xlmicBK5jtaCCHXzN4Q77AiBdIXTlJYCYsdcLsCsinlzxdqYvHiI/jLF8vmOfIEtcjQIgb7G/kfHjKD5SUe54FJOAxKRL/MLKLuaVwFNGSx1Ckts=";
// 1024 bits 的 RSA 密钥对，最大加密明文大小
private static final int MAX_ENCRYPT_BLOCK = 117;
// 1024 bits 的 RSA 密钥对，最大解密密文大小
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* 生成密钥对,一般使用固定 公钥
* @param keysize bits大小
* @return 公钥私钥map
* @throws Exception
*/
public static Map<String, Object> initKey(int keysize) throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
// 设置密钥对的 bit 数，越大越安全
keyPairGen.initialize(keysize);
KeyPair keyPair = keyPairGen.generateKeyPair();
// 获取公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// 获取私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, Object> keyMap = new HashMap<>(2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 生成公钥字符串，一般固定公钥
* @param keyMap 公钥私钥 map
* @return 公钥
*/
public static String getPublicKeyStr(Map<String, Object> keyMap) {
// 获得 map 中的公钥对象，转为 key 对象
Key key = (Key) keyMap.get(PUBLIC_KEY);
// 编码返回字符串
return encryptBASE64(key.getEncoded());
}
/**
* 生成私钥字符串，一般固定私钥
* @param keyMap 公钥私钥 map
* @return 私钥
*/
public static String getPrivateKeyStr(Map<String, Object> keyMap) {
// 获得 map 中的私钥对象，转为 key 对象
Key key = (Key) keyMap.get(PRIVATE_KEY);
// 编码返回字符串
return encryptBASE64(key.getEncoded());
}
/**
* 生成公钥对象，一般固定
* @param publicKeyString 公公钥字符串
* @return PublicKey
*/
public static PublicKey getPublicKey(String publicKeyString) throws NoSuchAlgorithmException, InvalidKeySpecException {
byte[] publicKeyByte = Base64.getDecoder().decode(publicKeyString);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyByte);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generatePublic(keySpec);
}
/**
* 生成私钥对象，一般固定
* @param privateKeyString 私钥字符串
* @return PrivateKey
*/
public static PrivateKey getPrivateKey(String privateKeyString) throws Exception {
byte[] privateKeyByte = Base64.getDecoder().decode(privateKeyString);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyByte);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return keyFactory.generatePrivate(keySpec);
}
/**
* BASE64 编码返回加密字符串
*
* @param key 需要编码的字节数组
* @return 编码后的字符串
*/
public static String encryptBASE64(byte[] key) {
return new String(Base64.getEncoder().encode(key));
}
/**
* BASE64 解码，返回字节数组
*
* @param key 待解码的字符串
* @return 解码后的字节数组
*/
public static byte[] decryptBASE64(String key) {
return Base64.getDecoder().decode(key);
}
/**
* 公钥加密
*
* @param text 待加密的明文字符串
* @param publicKeyStr 公钥
* @return 加密后的密文
*/
public static String encrypt1(String text, String publicKeyStr) {
try {
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, getPublicKey(publicKeyStr));
byte[] tempBytes = cipher.doFinal(text.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(tempBytes);
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + text + "]时遇到异常", e);
}
}
/**
* 私钥解密
*
* @param secretText 待解密的密文字符串
* @param privateKeyStr 私钥
* @return 解密后的明文
*/
public static String decrypt1(String secretText, String privateKeyStr) {
try {
// 生成私钥
Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyStr));
// 密文解码
byte[] secretTextDecoded = Base64.getDecoder().decode(secretText.getBytes("UTF-8"));
byte[] tempBytes = cipher.doFinal(secretTextDecoded);
return new String(tempBytes);
} catch (Exception e) {
throw new RuntimeException("解密字符串[" + secretText + "]时遇到异常", e);
}
}
public static void main(String[] args) throws Exception {
Map<String, Object> keyMap;
String cipherText;
// 原始明文
String content = "你好";
// 生成密钥对
keyMap = initKey(1024);
String publicKey = getPublicKeyStr(keyMap);
System.out.printf("公钥:[%s]，长度:[%s]%n", publicKey, publicKey.length());
String privateKey = getPrivateKeyStr(keyMap);
System.out.printf("私钥:[%s]，长度:[%s]%n", privateKey, privateKey.length());
// 加密
cipherText = RsaUtil.encrypt1(content, RsaUtil.PUBLIC_KEY);
System.out.printf("加密后的密文:[%s]，长度:[%s]%n", cipherText, cipherText.length());
// 解密
String plainText = decrypt1("n/j4I03UccBCspfaEYa6r1GbwUVYxp4meWVLnjhRDXqVBs6Yo0+vSqpcac0i3AjlNN0cbPd3SxGhJP2OoxPVIA==", RsaUtil.PRIVATE_KEY);
System.out.printf("解密后明文:[%s]", plainText);
}
}
Vue
添加 rsa 加解密工具
rsa加解密工具
npm i jsencrypt -D
encryptlong是基于jsencrypt扩展的长文本分段加解密功能
npm i encryptlong -S
rsa加解密工具js
/**
* 如果异常，请 引入对应工具：
* npm i jsencrypt -D
* npm i encryptlong -S
*/
import JSEncrypt from 'jsencrypt' // 处理长文本数据时报错 jsencrypt.js Message too long for RSA
import Encrypt from 'encryptlong' // encryptlong是基于jsencrypt扩展的长文本分段加解密功能。
// 公钥私钥 由后端生成
// 公钥key
const publicKey = 'MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKYAav5NQz+peuSObG5e6JTF7gtJAV/hbW28uz/GirbhIGzloHxZVP/VyA+Xsvvz48h2dVs6llgCO6j5g72g9KsCAwEAAQ=='
// 私钥key
const privateKey = 'MIIBVAIBADANBgkqhkiG9w0BAQEFAASCAT4wggE6AgEAAkEApgBq/k1DP6l65I5sbl7olMXuC0kBX+Ftbby7P8aKtuEgbOWgfFlU/9XID5ey+/PjyHZ1WzqWWAI7qPmDvaD0qwIDAQABAkA1Ui8L7k9qlIrX/XOQ5EV6/DThRRr+7E8VD6lp6+FEqnjp29HMnPTto1GuKWnkmzilyWbpXoGbscoZ62Koj6UZAiEA22nFpyqOh7sTmohwaYZHyHJwNGYq4TaayndDqNfpkHcCIQDBrqJIVgb0lv/88GrdWUAzHE7YmEfLSQggjvqYBmOebQIhAJMeNehjkZQS7Q8V4wHuhp0xlmicBK5jtaCCHXzN4Q77AiBdIXTlJYCYsdcLsCsinlzxdqYvHiI/jLF8vmOfIEtcjQIgb7G/kfHjKD5SUe54FJOAxKRL/MLKLuaVwFNGSx1Ckts='
export default {
/**
* JSEncrypt加密，加密字符过场会异常
* @param {*} data 需要加密的字符
* @returns 加密后的字符
*/
rsaPublicData(data) {
var jsencrypt = new JSEncrypt()
jsencrypt.setPublicKey(publicKey)
// 如果是对象/数组的话，需要先JSON.stringify转换成字符串
var result = jsencrypt.encrypt(data)
return result
},
/**
* JSEncrypt解密，解密字符过场会异常
* @param {*} data 需要解密的字符
* @returns 解密后的字符
*/
rsaPrivateData(data) {
var jsencrypt = new JSEncrypt()
jsencrypt.setPrivateKey(privateKey)
// 如果是对象/数组的话，需要先JSON.stringify转换成字符串
var result = jsencrypt.encrypt(data)
return result
},
/**
* 加密,没有字符长度限制
* @param {*} data 需要加密的字符
* @returns 加密后的字符
*/
encrypt(data) {
const PUBLIC_KEY = publicKey
var encryptor = new Encrypt()
encryptor.setPublicKey(PUBLIC_KEY)
// 如果是对象/数组的话，需要先JSON.stringify转换成字符串
const result = encryptor.encryptLong(data)
return result
},
/**
* 解密 - PRIVATE_KEY - 验证,没有字符长度限制
* @param {*} data 需要解密的字符
* @returns 解密后的字符
*/
decrypt(data) {
const PRIVATE_KEY = privateKey
var encryptor = new Encrypt()
encryptor.setPrivateKey(PRIVATE_KEY)
// 如果是对象/数组的话，需要先JSON.stringify转换成字符串
var result = encryptor.decryptLong(data)
return result
}
}