RSA是一种非对称加密算法,拥有一对密钥(公钥和私钥),由公钥加密的数据只能由私钥解密,由私钥加密的数据只能由公钥解密。
public class RsaUtils {
//加密算法RSA
private static final String ALGORITHM = "RSA";
//密钥长度
private static final int KEY_SIZE = 1024;
//公钥文件
private static final String PUBLIC_KEY_FILE = "PublicKey";
//密钥文件
private static final String PRIVATE_KEY_FILE = "PrivateKey";
/**
* @Title: generateKeyPair
* @Description: TODO(生成并保存密钥对)
* @author mervyn
* @date 2020年05月21日 10:59:07
* @param
* @return void
* @throws
*/
public static void generateKeyPair() {
//获取一个RSA算法的密钥生成实例
KeyPairGenerator keyPairGenerator = null;
try {
keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
//初始化密钥长度
keyPairGenerator.initialize(KEY_SIZE);
//生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//编码处理,方便保存
String publicKeyStr = new BASE64Encoder().encode(publicKey.getEncoded());
String privateKeyStr = new BASE64Encoder().encode(privateKey.getEncoded());
//保存输出流
BufferedWriter pubBw = null;
BufferedWriter priBw = null;
try {
pubBw = new BufferedWriter(new FileWriter(PUBLIC_KEY_FILE));
priBw = new BufferedWriter(new FileWriter(PRIVATE_KEY_FILE));
pubBw.write(publicKeyStr);
priBw.write(privateKeyStr);
pubBw.flush();
priBw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (pubBw != null) {
try {
pubBw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (priBw != null) {
try {
priBw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* @Title: getPublicKey
* @Description: TODO(获取公钥)
* @author mervyn
* @date 2020年05月21日 11:27:49
* @param
* @return java.security.interfaces.RSAPublicKey
* @throws
*/
private static RSAPublicKey getPublicKey() {
//输入流
BufferedReader pubBr = null;
RSAPublicKey publicKey = null;
try {
pubBr = new BufferedReader(new FileReader(PUBLIC_KEY_FILE));
String line = null;
StringBuilder publicKeyEncode = new StringBuilder();
while ((line = pubBr.readLine()) != null) {
publicKeyEncode.append(line);
}
//base64转为byte
byte[] publicKeyByte = new BASE64Decoder().decodeBuffer(publicKeyEncode.toString());
//获取指定算法的密钥工厂, 根据 已编码的公钥规格, 生成公钥对象
X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(publicKeyByte);
publicKey = (RSAPublicKey) KeyFactory.getInstance(ALGORITHM).generatePublic(encodedKeySpec);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (pubBr != null) {
try {
pubBr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return publicKey;
}
/**
* @Title: getPrivateKey
* @Description: TODO(获取私钥)
* @author mervyn
* @date 2020年05月21日 13:56:34
* @param
* @return java.security.interfaces.RSAPrivateKey
* @throws
*/
private static RSAPrivateKey getPrivateKey() {
//输入流
BufferedReader priBr = null;
RSAPrivateKey privateKey = null;
try {
priBr = new BufferedReader(new FileReader(PRIVATE_KEY_FILE));
String line = null;
StringBuilder privateKeyEncode = new StringBuilder();
while ((line = priBr.readLine()) != null) {
privateKeyEncode.append(line);
}
//base64转为byte
byte[] privateKeyByte = new BASE64Decoder().decodeBuffer(privateKeyEncode.toString());
//获取指定算法的密钥工厂, 根据 已编码的私钥规格, 生成私钥对象
PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(privateKeyByte);
privateKey = (RSAPrivateKey) KeyFactory.getInstance(ALGORITHM).generatePrivate(encodedKeySpec);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (priBr != null) {
try {
priBr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return privateKey;
}
/**
* @Title: encrypt
* @Description: TODO(公钥加密)
* @author mervyn
* @date 2020年05月21日 14:00:56
* @param sourceStr
* @return java.lang.String
* @throws
*/
public static String encrypt(String sourceStr) {
//获取公钥
RSAPublicKey publicKey = getPublicKey();
String encodeStr = null;
try {
//RSA加密
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
encodeStr = new BASE64Encoder().encode(cipher.doFinal(sourceStr.getBytes()));
} catch (Exception e) {
e.printStackTrace();
}
return encodeStr;
}
/**
* @Title: decrypt
* @Description: TODO(私钥解密)
* @author mervyn
* @date 2020年05月21日 14:05:53
* @param encodeStr
* @return java.lang.String
* @throws
*/
public static String decrypt(String encodeStr) {
//获取私钥
RSAPrivateKey privateKey = getPrivateKey();
String sourceStr = null;
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
sourceStr = new String(cipher.doFinal(new BASE64Decoder().decodeBuffer(encodeStr)));
} catch (Exception e) {
e.printStackTrace();
}
return sourceStr;
}
}
public static void main(String[] args) {
RsaUtils.generateKeyPair();
String source = "RSA非对称加解密DEMO";
System.out.println("源文: " + source);
String encryptStr = RsaUtils.encrypt(source);
System.out.println("加密: " + encryptStr);
String decryptStr = RsaUtils.decrypt(encryptStr);
System.out.println("解密: " + decryptStr);
}
运行结果:
源文: RSA非对称加解密DEMO
加密: moyPJXwzpeRsq3OzaEesILDQ9L23+wqCe+FOztIkXuEYkt+aWdsZjrP+cFi4lasVf3iBXjrQWR1H
DfAavszchn8FUmFveZvwgBPi5E9lcdvWN+uuPiA9UkkisMvV+dtRn1eBnpW6XvoEQ1CNahI+ZKst
+pQGf8Gqer0UWFCzVHA=
解密: RSA非对称加解密DEMO
//最大加密长度
private static final int MAX_ENCRYPT_BLOCK = KEY_SIZE / 8 -11;
//最大解密长度
private static final int MAX_DECRYPT_BLOCK = KEY_SIZE / 8;
/**
* @Title: encryptSegment
* @Description: TODO(分段加密)
* @author mervyn
* @date 2020年05月21日 16:07:04
* @param sourceStr
* @return java.lang.String
* @throws
*/
public static String encryptSegment(String sourceStr) {
//获取公钥
RSAPublicKey publicKey = getPublicKey();
String encryptStr = null;
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
//获取源文字节
byte[] sourceByte = sourceStr.getBytes();
//源文长度
int sourceLen = sourceByte.length;
//偏离度
int offset = 0;
//分段次数
int tmp = 0;
//分段缓存
byte[] cache;
ByteArrayOutputStream out = new ByteArrayOutputStream();
//循环字节
while (sourceLen - offset > 0) {
if (sourceLen - offset > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(sourceByte, offset, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(sourceByte, offset, sourceLen - offset);
}
out.write(cache, 0, cache.length);
tmp++;
offset = tmp * MAX_ENCRYPT_BLOCK;
}
byte[] result = out.toByteArray();
out.close();
encryptStr = new BASE64Encoder().encode(result);
} catch (Exception e) {
e.printStackTrace();
}
return encryptStr;
}
/**
* @Title: decryptSegment
* @Description: TODO(分段解密)
* @author mervyn
* @date 2020年05月21日 16:34:34
* @param encryptStr
* @return java.lang.String
* @throws
*/
public static String decryptSegment (String encryptStr) {
//获取私钥
RSAPrivateKey privateKey = getPrivateKey();
String sourceStr = null;
try {
Cipher cipher = Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
//获取加密文字节
byte[] encryptByte = new BASE64Decoder().decodeBuffer(encryptStr);
//加密文长度
int encryptLen = encryptByte.length;
//偏离度
int offset = 0;
//分段次数
int tmp = 0;
//分段缓存
byte[] cache;
ByteArrayOutputStream out = new ByteArrayOutputStream();
//循环字节
while (encryptLen - offset > 0) {
if (encryptLen - offset > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(encryptByte, offset, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(encryptByte, offset, encryptLen - offset);
}
out.write(cache, 0, cache.length);
tmp++;
offset = tmp * MAX_DECRYPT_BLOCK;
}
byte[] result = out.toByteArray();
out.close();
sourceStr = new String(result);
} catch (Exception e) {
e.printStackTrace();
}
return sourceStr;
}
public static void main(String[] args) {
RsaUtils.generateKeyPair();
String source = "既然如此, 了解清楚科学和人文谁更有意义到底是一种怎么样的存在,是解决一切问题的关键。 奥普拉·温弗瑞曾经提到过,你相信什么,你就成为什么样的人。这句话语虽然很短,但令我浮想联翩。 伏尔泰曾经说过,坚持意志伟大的事业需要始终不渝的精神。这不禁令我深思。 要想清楚,科学和人文谁更有意义,到底是一种怎么样的存在。 一般来讲,我们都必须务必慎重的考虑考虑。 我们不得不面对一个非常尴尬的事实,那就是, 这样看来。";
System.out.println("源文: " + source);
String encryptStr = RsaUtils.encryptSegment(source);
System.out.println("加密: " + encryptStr);
String decryptStr = RsaUtils.decryptSegment(encryptStr);
System.out.println("解密: " + decryptStr);
}
运行结果:
源文: 既然如此, 了解清楚科学和人文谁更有意义到底是一种怎么样的存在,是解决一切问题的关键。 奥普拉·温弗瑞曾经提到过,你相信什么,你就成为什么样的人。这句话语虽然很短,但令我浮想联翩。 伏尔泰曾经说过,坚持意志伟大的事业需要始终不渝的精神。这不禁令我深思。 要想清楚,科学和人文谁更有意义,到底是一种怎么样的存在。 一般来讲,我们都必须务必慎重的考虑考虑。 我们不得不面对一个非常尴尬的事实,那就是, 这样看来。
加密: jy15NKLCixEsHtTO1civuIPEGqjhIqjM3AaOt/GGwQMNGuEnd+LbD/qFeLaiONi3OVxy9NVQXziR
T1l4TrPIvb33kxCdFpwWv0mvTZwnHCloQpmuLRGr4LFH1/7H6/WIYK+NK82S74sH0HiHMUiTpoVp
TQsoJYA8NRyFpbNlIwIMFKSkkUJdBtDBFktFkNmgOzMKBBQwo2q/r3RG83rCW9IByrrxX9KtBAXF
stp1lE8fsKGhjrNbAkb3Ouy08i5Lh9oDbpkai/YBV3otGU2Yx3EGZM7YKOw7EvzknirMBo6qt0Q/
VbKnVD4npQ7FywhyTY668l9EsTPvBDyO6zDgZn6PhVroxDYIc/PCbakK4y1XGgew1ZvFq/I7NA3P
rIkgj1ICzH+XO6oc/xgK7jlEhcXPolngNI3AdUjUmI8qmfpQzMuYBoB3lX38GmhjWONZkxASu1S3
K+4XmSGB2a5o/fJxCV4jsqUAHhjua9dSN5A2Kdtnzm8MmyUPzwaCz+qNCmwpNEe6Sqvl/Nm4hgBm
8tHRt/vKsgh7oyrt3Y2MVf9lvomcIeEtNnZfd19KrOkMuj2vYIDvjLwbNAB/K+tC5Q5OuxHS3IBn
KnMGh1Do02fQtESYCrlIT4f3Q4eeQ0GR3tpD4Wg1Z6kWQkDbAWGMvQX2f9WTAEbCZ0heY2e6eu5P
nMf0pm/q0qd9hP6TFPBwO7biSVTSPSGtBBpDtRijFI1g3kdWO+35xDyylv0+7EP3k+qPBdNmiTHW
hIYOSxuoLhNWW48K4mJ/rJ9pP8UtOqqH9/9BdNVwnc8WOEz7EZEk8so9zmdJXZstgV48CpFIAcO4
4NhxvV4vh8Gb42efdPlGaWk12Bzlm1CPk/4ZBQZadNaRnr/WgTiJLsulvVsxjnLH2BiXfsUpKG9U
PwP9foXX0OwkB+82i6w9+WKLB7E8OCWN6YeGE/U4JHO/SvzPx5PAy89UaLnG2J7Ld9s0hfbZo09K
iXxhOOj2/wCL5NQQcPKSSpCiCNe4tlICGMpu
解密: 既然如此, 了解清楚科学和人文谁更有意义到底是一种怎么样的存在,是解决一切问题的关键。 奥普拉·温弗瑞曾经提到过,你相信什么,你就成为什么样的人。这句话语虽然很短,但令我浮想联翩。 伏尔泰曾经说过,坚持意志伟大的事业需要始终不渝的精神。这不禁令我深思。 要想清楚,科学和人文谁更有意义,到底是一种怎么样的存在。 一般来讲,我们都必须务必慎重的考虑考虑。 我们不得不面对一个非常尴尬的事实,那就是, 这样看来。