一、概述
1.RSA是基于大数因子分解难题。目前各种主流计算机语言都支持RSA算法的实现
2.java6支持RSA算法
3.RSA算法可以用于数据加密和数字签名
4.RSA算法相对于DES/AES等对称加密算法，他的速度要慢的多
5.总原则：公钥加密，私钥解密 / 私钥加密，公钥解密
二、模型分析
RSA算法构建密钥对简单的很，这里我们还是以甲乙双方发送数据为模型
1.甲方在本地构建密钥对（公钥+私钥），并将公钥公布给乙方
2.甲方将数据用私钥进行加密，发送给乙方
3.乙方用甲方提供的公钥对数据进行解密
如果乙方向传送数据给甲方：
4.乙方用公钥对数据进行加密，然后传送给甲方
5.甲方用私钥对数据进行解密
三、代码分析
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.ArrayUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.server.ResponseStatusException;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
/**
* 非对称加密 - 网上随便摘抄了一个
* @date 2020/12/6 13:38
* @author wei.heng
*/
public class RSACoderUtil {
static Logger log = LoggerFactory.getLogger(RSACoderUtil.class);
/** 非对称密钥算法 */
private static final String KEY_ALGORITHM = "RSA";
/**
* 密钥长度，DH算法的默认密钥长度是1024
* 密钥长度必须是64的倍数，在512到65536位之间
*/
private static final int KEY_SIZE = 512;
/** 公钥 */
private static final String PUBLIC_KEY = "RSAPublicKey";
/** 私钥 */
private static final String PRIVATE_KEY = "RSAPrivateKey";
/** RSA最大加密明文大小 */
private static final int MAX_ENCRYPT_BLOCK = 53;
/** RSA最大解密明文大小 */
private static final int MAX_DECRYPT_BLOCK = KEY_SIZE / 8;
/**
* 初始化密钥对
*
* @return Map 甲方密钥的Map
*/
public static Map<String, Object> initKey() throws Exception {
//实例化密钥生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
//初始化密钥生成器
keyPairGenerator.initialize(KEY_SIZE);
//生成密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//甲方公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//甲方私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//将密钥存储在map中
Map<String, Object> keyMap = new HashMap<>(2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 私钥加密
*
* @param data 待加密数据
* @param key 密钥
* @return byte[] 加密数据
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
// 如果报文长度大于最大长度，则进行分段加密
byte[] enBytes = null;
if(data.length > MAX_ENCRYPT_BLOCK){
for (int i = 0; i < data.length; i += MAX_ENCRYPT_BLOCK) {
// 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_ENCRYPT_BLOCK));
enBytes = ArrayUtils.addAll(enBytes, doFinal);
}
} else {
enBytes = cipher.doFinal(data);
}
return enBytes;
}
/**
* 公钥加密
*
* @param data 待加密数据
* @param key 密钥
* @return byte[] 加密数据
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
// 如果报文长度大于最大长度，则进行分段加密
byte[] enBytes = null;
if(data.length > MAX_ENCRYPT_BLOCK){
for (int i = 0; i < data.length; i += MAX_ENCRYPT_BLOCK) {
// 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_ENCRYPT_BLOCK));
enBytes = ArrayUtils.addAll(enBytes, doFinal);
}
} else {
enBytes = cipher.doFinal(data);
}
return enBytes;
}
/**
* 私钥解密
*
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
*/
public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
//数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
// 分段解密
byte[] deBytes = null;
if(data.length > MAX_DECRYPT_BLOCK){
for (int i = 0; i < data.length; i += MAX_DECRYPT_BLOCK) {
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_DECRYPT_BLOCK));
deBytes = ArrayUtils.addAll(deBytes, doFinal);
}
} else {
deBytes = cipher.doFinal(data);
}
return deBytes;
}
/**
* 公钥解密
*
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {
//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, pubKey);
// 分段解密
byte[] deBytes = null;
if(data.length > MAX_DECRYPT_BLOCK){
for (int i = 0; i < data.length; i += MAX_DECRYPT_BLOCK) {
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + MAX_DECRYPT_BLOCK));
deBytes = ArrayUtils.addAll(deBytes, doFinal);
}
} else {
deBytes = cipher.doFinal(data);
}
return deBytes;
}
/**
* 取得私钥
*
* @param keyMap 密钥map
* @return byte[] 私钥
*/
public static byte[] getPrivateKey(Map<String, Object> keyMap) {
Key key = (Key) keyMap.get(PRIVATE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
*
* @param keyMap 密钥map
* @return byte[] 公钥
*/
public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
/**
*
* 私钥解密 - 供网关请求拦截使用
* @param privateKey 解密用的私钥
* @param body base64转义后的 加密的字符串
* @return byte[] 解密后的字节数组
* @date 2020/12/9 10:52
* @author wei.heng
*/
public static byte[] getDecodedBytes(byte[] privateKey, String body) {
byte[] encodeBytes = Base64.decodeBase64(body.getBytes());
byte[] decodedBytes;
try {
// 私钥解密
decodedBytes = RSACoderUtil.decryptByPrivateKey(encodeBytes, privateKey);
} catch (Exception e) {
e.printStackTrace();
log.error("解密异常：" + e.getMessage());
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "请求解密异常");
}
return decodedBytes;
}
// /** 自测
// * @param args
// * @throws Exception
// */
// public static void main(String[] args) throws Exception {
// //初始化密钥
// //生成密钥对
Map<String, Object> keyMap = RSACoderUtil.initKey();
//公钥
byte[] publicKey = RSACoderUtil.getPublicKey(keyMap);
//私钥
byte[] privateKey = RSACoderUtil.getPrivateKey(keyMap);
System.out.println("公钥：\n" + Base64.encodeBase64String(publicKey));
System.out.println("私钥：\n" + Base64.encodeBase64String(privateKey));
// String privateKeyStr = "MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAkttYlG9umVKH8AmguAfobwOdILxh9Le+bJ6zmOJskDpPmg609s/ZNjua+4LAhfwVXzKL5ZUYz2vCEtYuLqafhwIDAQABAkBrLbaKLoFTWM5pOz2W0f6q9sI4YARFq8xITdLZY3bEEwz34GnNwzUClmwoxlkZDx+0ew1NErCZXNee6+6cZlkxAiEA3YlZ+aIzJJPdTQ9t+EhJvvXR6DDBap2Uv4f64ZV4j9UCIQCps+PP7NjksC4pcf4kh0HfA87zilnlbhaXAWbLB0K76wIgY78oJ+IELP/2sG+2EAhcTALalDT/oUV6aBKNv2xRcFECICk1P3p7/ub5SRxTS+0+0uX+nMBStiWaJ+4fLwDaEIBlAiBiI4Y7bjDBXTZEKVTsu8GoH70UhKAWRHv+a3Aq1cyFng==";
// String publicKeyStr = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJLbWJRvbplSh/AJoLgH6G8DnSC8YfS3vmyes5jibJA6T5oOtPbP2TY7mvuCwIX8FV8yi+WVGM9rwhLWLi6mn4cCAwEAAQ==";
// byte[] publicKey = Base64.decodeBase64(publicKeyStr);
// byte[] privateKey = Base64.decodeBase64(privateKeyStr);
//
// System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
// String str = "{\"code\":200,\"msg\":null,\"data\":{\"testName\":\"12344\",\"nicName\":\"33333\"}}";
// System.out.println("/n===========甲方向乙方发送加密数据==============");
// System.out.println("原文:" + str);
// //甲方进行数据的加密
// byte[] code1 = RSACoderUtil.encryptByPrivateKey(str.getBytes(), privateKey);
// System.out.println("加密后的数据：" + Base64.encodeBase64String(code1));
// System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
// //乙方进行数据的解密
//
// byte[] tt = Base64.decodeBase64("EQmR6grGhpbaAzBqW31shlEzp9EwL4v4BQBSWOdf7BT5zKNgEYFINUCDHFJKYxeUtVOoiizrGHmicWDQSWcx+4BghnCyQob5kQD6KDcHBA+OTUL0vIY/EzJcV9XAasn/vdtACTz6N3MOUC7dEoqlh2cy2i9A+58oenSMfjzKDSw=");
// byte[] decode1 = RSACoderUtil.decryptByPublicKey(tt, publicKey);
// System.out.println("乙方解密后的数据：" + new String(decode1) + "/n/n");
//
// System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");
//
//
//
//
//
// str = "hello=helloworld&hei=yoyochecknow";
// System.out.println("原文:" + str);
//
// //乙方使用公钥对数据进行加密
// byte[] code2 = RSACoderUtil.encryptByPublicKey(str.getBytes(), publicKey);
// System.out.println("===========乙方使用公钥对数据进行加密==============");
// System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));
//
// System.out.println("=============乙方将数据传送给甲方======================");
// System.out.println("===========甲方使用私钥对数据进行解密==============");
//
// //甲方使用私钥对数据进行解密
// byte[] decode2 = RSACoderUtil.decryptByPrivateKey(code2, privateKey);
//
// System.out.println("甲方解密后的数据：" + new String(decode2));
// }
}
四、总结
1.RSA与DH算法不同，只需要一套密钥就能完成加密、解密的工作
2.通过代码能看出来，公钥长度明显小于私钥
3.遵循：公钥加密-私钥解密，私钥加密-公钥解密的原则
4.公钥和私钥肯定是完全不同
扫一扫
1163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
