277 lines
10 KiB
Java
277 lines
10 KiB
Java
package com.sf.vertx.security;
|
||
|
||
|
||
import javax.crypto.BadPaddingException;
|
||
import javax.crypto.Cipher;
|
||
import javax.crypto.IllegalBlockSizeException;
|
||
import javax.crypto.NoSuchPaddingException;
|
||
import java.io.ByteArrayOutputStream;
|
||
import java.io.IOException;
|
||
import java.io.UnsupportedEncodingException;
|
||
import java.security.*;
|
||
import java.security.spec.InvalidKeySpecException;
|
||
import java.security.spec.PKCS8EncodedKeySpec;
|
||
import java.security.spec.X509EncodedKeySpec;
|
||
import java.util.List;
|
||
|
||
/**
|
||
* 本类进行非对称加密，不推荐使用非对称加密对长字符串进行加密或者解密，徒增资源消耗，另外由于长度限制，过长的字符串的加密和解密会使用循环，对数据分段加密；本类采用的
|
||
* 密钥字符串均为Base64加密后的
|
||
* 另外所有异常都会抛出
|
||
* 下面将会列举几个可以自定义或者暴露出去的接口和参数
|
||
* {@link #IS_LONG_TEXT} 是否否对长文本处理
|
||
* {@link #RESULT_TYPE} 密文结果：1=base64 2=hex
|
||
* {@link #RSA_ALGORITHM} RSA算法
|
||
* {@link #encrypt(String, String)} 加密方法
|
||
* {@link #decrypt(String, String)} 解密方法
|
||
* {@link #getKeyPair} 解密方法
|
||
*/
|
||
public class RSA2Utils {
|
||
/**
|
||
* 是否对长文本加密；请参照{@link #MAX_DECRYPT_BLOCK}和{@link #MAX_ENCRYPT_BLOCK}
|
||
*/
|
||
private static final boolean IS_LONG_TEXT = true;
|
||
/**
|
||
* 结果类型
|
||
*/
|
||
private static final int RESULT_TYPE = 2;
|
||
/**
|
||
* RSA 算法
|
||
*/
|
||
private static final String RSA_ALGORITHM = "RSA";
|
||
/**
|
||
* 长文本解密块大小
|
||
*/
|
||
private static final int MAX_DECRYPT_BLOCK = 128;
|
||
/**
|
||
* 长文本加密块大小
|
||
*/
|
||
private static final int MAX_ENCRYPT_BLOCK = 117;
|
||
/**
|
||
* KyeSize
|
||
*/
|
||
private static final int KEY_SIZE = 2048;
|
||
|
||
/**
|
||
* 加密
|
||
*
|
||
* @param content 待加密的字符串
|
||
* @param pubKey 公钥字符串
|
||
* @return 加密后的文本
|
||
* @throws Exception 异常
|
||
*/
|
||
public static String encrypt(String content, String pubKey) throws Exception {
|
||
byte[] data = StringUtils.getBytes(content);
|
||
PublicKey publicKey = string2PubKey(pubKey);
|
||
byte[] resultArr;
|
||
if (IS_LONG_TEXT) {
|
||
resultArr = encryptLongStr(data, publicKey);
|
||
} else {
|
||
resultArr = encrypt(data, publicKey);
|
||
}
|
||
String result;
|
||
switch (RESULT_TYPE) {
|
||
case 1:
|
||
result = Base64Utils.encode(resultArr);
|
||
break;
|
||
case 2:
|
||
result = HexUtils.bytes2Hex(resultArr);
|
||
break;
|
||
default:
|
||
throw new Exception("Unsupport result type");
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @param content 密文内容
|
||
* @param priKey 私钥
|
||
* @return 解密后的字符串
|
||
* @throws Exception 异常
|
||
*/
|
||
public static String decrypt(String content, String priKey) throws Exception {
|
||
byte[] data;
|
||
switch (RESULT_TYPE) {
|
||
case 1:
|
||
data = Base64Utils.decode(content);
|
||
break;
|
||
case 2:
|
||
data = HexUtils.hex2Bytes(content);
|
||
break;
|
||
default:
|
||
throw new Exception("Unsupport result type");
|
||
}
|
||
PrivateKey privateKey = string2PrivateKey(priKey);
|
||
byte[] result;
|
||
if (IS_LONG_TEXT) {
|
||
result = decryptLongStr(data, privateKey);
|
||
} else {
|
||
result = decrypt(privateKey, data);
|
||
}
|
||
return StringUtils.bytes2String(result);
|
||
}
|
||
|
||
/**
|
||
* 响应公私钥对
|
||
*
|
||
* @return 0号 公钥 1号 私钥
|
||
* @throws NoSuchAlgorithmException 异常
|
||
*/
|
||
public static List<String> getKeyPair() throws NoSuchAlgorithmException {
|
||
KeyPair keyPairObj = getKeyPairObj();
|
||
return List.of(Base64Utils.encode(keyPairObj.getPublic().getEncoded()), Base64Utils.encode(keyPairObj.getPrivate().getEncoded()));
|
||
}
|
||
|
||
/**
|
||
* 将公钥字符串转化为对象
|
||
*
|
||
* @param s base64字符串
|
||
* @return 公钥
|
||
* @throws NoSuchAlgorithmException 异常
|
||
* @throws UnsupportedEncodingException 异常
|
||
* @throws InvalidKeySpecException 异常
|
||
*/
|
||
private static PublicKey string2PubKey(String s) throws NoSuchAlgorithmException, UnsupportedEncodingException, InvalidKeySpecException {
|
||
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
|
||
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64Utils.decode(s));
|
||
return keyFactory.generatePublic(keySpec);
|
||
}
|
||
|
||
/**
|
||
* 对段字符串进行加密
|
||
*
|
||
* @param bytes 字节数组
|
||
* @param publicKey 公钥
|
||
* @return 加密后的数组
|
||
* @throws InvalidKeyException 异常
|
||
* @throws BadPaddingException 异常
|
||
* @throws IllegalBlockSizeException 异常
|
||
* @throws NoSuchPaddingException 异常
|
||
* @throws NoSuchAlgorithmException 异常
|
||
*/
|
||
private static byte[] encrypt(byte[] bytes, PublicKey publicKey) throws InvalidKeyException, BadPaddingException, IllegalBlockSizeException, NoSuchPaddingException, NoSuchAlgorithmException {
|
||
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
|
||
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
|
||
return cipher.doFinal(bytes);
|
||
}
|
||
|
||
/**
|
||
* 对长字符串进行加密
|
||
*
|
||
* @param bytes 字节数组
|
||
* @param publicKey 公钥
|
||
* @return 加密后的数组
|
||
* @throws NoSuchPaddingException 异常
|
||
* @throws NoSuchAlgorithmException 异常
|
||
* @throws InvalidKeyException 异常
|
||
*/
|
||
private static byte[] encryptLongStr(byte[] bytes, PublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException {
|
||
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
|
||
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
|
||
int inputLen = bytes.length;
|
||
byte[] encryptedData = new byte[0];
|
||
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
|
||
int offSet = 0;
|
||
byte[] cache;
|
||
int i = 0;
|
||
// 对数据分段加密
|
||
while (inputLen - offSet > 0) {
|
||
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
|
||
cache = cipher.doFinal(bytes, offSet, MAX_ENCRYPT_BLOCK);
|
||
} else {
|
||
cache = cipher.doFinal(bytes, offSet, inputLen - offSet);
|
||
}
|
||
out.write(cache, 0, cache.length);
|
||
i++;
|
||
offSet = i * MAX_ENCRYPT_BLOCK;
|
||
}
|
||
encryptedData = out.toByteArray();
|
||
} catch (IOException | BadPaddingException | IllegalBlockSizeException e) {
|
||
e.printStackTrace();
|
||
}
|
||
return encryptedData;
|
||
}
|
||
|
||
/**
|
||
* 私钥字符串转为私钥对象
|
||
*
|
||
* @param priStr 私钥字符串
|
||
* @return 私钥对象
|
||
* @throws NoSuchAlgorithmException 异常
|
||
* @throws InvalidKeySpecException 异常
|
||
*/
|
||
private static PrivateKey string2PrivateKey(String priStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
|
||
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64Utils.decode(priStr));
|
||
KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
|
||
return keyFactory.generatePrivate(keySpec);
|
||
}
|
||
|
||
/**
|
||
* 解密
|
||
*
|
||
* @param privateKey 私钥
|
||
* @param bytes 字节数组
|
||
* @return 解密后的字节数组
|
||
* @throws NoSuchPaddingException 异常
|
||
* @throws NoSuchAlgorithmException 异常
|
||
* @throws BadPaddingException 异常
|
||
* @throws IllegalBlockSizeException 异常
|
||
* @throws InvalidKeyException 异常
|
||
*/
|
||
public static byte[] decrypt(PrivateKey privateKey, byte[] bytes) throws NoSuchPaddingException, NoSuchAlgorithmException, BadPaddingException, IllegalBlockSizeException, InvalidKeyException {
|
||
Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
|
||
cipher.init(Cipher.DECRYPT_MODE, privateKey);
|
||
return cipher.doFinal(bytes);
|
||
}
|
||
|
||
/**
|
||
* 解密
|
||
*
|
||
* @param data 解密前的字节数组
|
||
* @param privateKey 私钥
|
||
* @return 解密后的字节数组
|
||
* @throws InvalidKeyException 异常
|
||
* @throws NoSuchPaddingException 异常
|
||
* @throws NoSuchAlgorithmException 异常
|
||
*/
|
||
public static byte[] decryptLongStr(byte[] data, PrivateKey privateKey) throws InvalidKeyException, NoSuchPaddingException, NoSuchAlgorithmException {
|
||
Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
|
||
cipher.init(Cipher.DECRYPT_MODE, privateKey);
|
||
int inputLen = data.length;
|
||
byte[] result = new byte[0];
|
||
try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
|
||
int offSet = 0;
|
||
byte[] cache;
|
||
int i = 0;
|
||
// 对数据分段解密
|
||
while (inputLen - offSet > 0) {
|
||
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
|
||
cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
|
||
} else {
|
||
cache = cipher.doFinal(data, offSet, inputLen - offSet);
|
||
}
|
||
out.write(cache, 0, cache.length);
|
||
i++;
|
||
offSet = i * MAX_DECRYPT_BLOCK;
|
||
}
|
||
result = out.toByteArray();
|
||
} catch (BadPaddingException | IllegalBlockSizeException | IOException e) {
|
||
e.printStackTrace();
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 获得一堆公私钥
|
||
*
|
||
* @return KeyPair对象
|
||
* @throws NoSuchAlgorithmException 异常
|
||
*/
|
||
private static KeyPair getKeyPairObj() throws NoSuchAlgorithmException {
|
||
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
|
||
SecureRandom secureRandom = new SecureRandom(StringUtils.getBytes(String.valueOf(System.currentTimeMillis())));
|
||
keyPairGenerator.initialize(KEY_SIZE, secureRandom);
|
||
return keyPairGenerator.genKeyPair();
|
||
}
|
||
}
|