一、简介
RSA是最流行的非对称加密算法之一。也被称为公钥加密。
RSA是非对称的,也就是用来加密的密钥和用来解密的密钥不是同一个。【敌人怎么破解?】
RSA作为一种非对称的加密算法,其中很重要的一特点是当数据在网络中传输时,用来加密数据的密钥并不需要也和数据一起传送。因此,这就减少了密钥泄露的可能性。
RSA在不允许加密方解密数据时也很有用,加密的一方使用一个密钥,称为公钥,解密的一方使用另一个密钥,称为私钥,私钥需要保持其私有性。【注:公私钥需要配对,不然木法解密】
二、RSA加密、签名区别
加密和签名都是为了安全性考虑,但略有不同。 加密是为了防止信息被泄露,而签名是为了防止信息被篡改。
eg1:
第一个场景:战场上,P要给H传递一条消息,内容为某一指令。【P为第三方支付平台:H为商户平台】 RSA的加密过程如下: (1)H生成一对密钥(公钥和私钥),H私钥不公开自己保留。H公钥为公开的,任何人可以获取。 (2)H传递自己的公钥给P,P用H的公钥对消息进行加密。【支付平台发的消息,是用的商户的公钥进行加密的,这样商户才能根据自己手里的私钥进行解密】 (3)H接收到P(用H的公钥)加密的消息,利用H自己的私钥对消息进行解密。【商户收到支付平台回调消息,用自己的私钥进行解密】 在这个过程中,值有2次传递过程,第一次是商户传递公钥给平台,第二次是平台传递加密消息给商户,即使都被敌方截获,也没有危险性,因为只有商户的私钥才能对消息进行解密,防止了消息内容的泄露。【但是不能防止篡改!】 |
倒过来看: 商户要给平台传递一条消息,内容为某一指令 平台生成一对秘钥【公钥与私钥】,私钥平台自己保留,然后公钥对外公开。 商户拿到平台公开的私钥,然后对要发送的信息,使用平台的公钥进行加密,然后发送给平台 平台接受到加密的消息之后,用未公开的商户私钥进行解密。 |
【第一个场景虽然被截获的消息没有泄露,但是可以利用截获的公钥,将假指令进行加密,然后传递给A】
第二个场景:
RSA签名的过程如下: (1)H生成一对密钥(公钥和私钥),H的私钥不公开,H自己保留。公钥为公开的,任何人可以获取。 (2)H用自己的私钥对消息加签,形成 签名,并将加签的消息和消息本身一起传递给平台。 (3)P收到消息后,在获取H的公钥进行验签,如果验签出来的内容与消息本身一致,证明消息是H发送的。 在这个过程中,只有2次传递过程,第一次是商户传递加签的消息和消息本身给B,第二次是平台获取商户的公钥,即使都被敌方截获,也没有危险性,因为只有商户的私钥才能对消息进行签名,即使知道了消息内容,也无法伪造带签名的回复给平台,防止了消息内容的篡改。 |
【第二个场景可以防止篡改,但是信息都TM漏了!】
上述两种情况都不完美: 要根据情况使用,也可以同时使用加密和签名,
比如A和B都有一套自己的公钥和私钥,当A要给B发送消息时,先用B的公钥对消息加密,再对加密的消息使用自己的【A的】私钥加签名,达到既不泄露也不被篡改,更能保证消息的安全性。【先后顺序是确定的嘛?先加密后签名】
总结:别人的公钥加密、自己的私钥解密、自己的私钥签名、别人的公钥验签。
完美情况:
SH:商户 -------------- PT:支付平台
SH生成一对公私钥,分别为SH公钥与SH私钥;PT生成一对公私钥,分别为PT公钥与PT私钥。
下面我要模拟支付的过程,进行说明整个流程。
(1) SH与PT互相交换公钥。私钥各自留存
(2) SH 发起支付请求,SH首先用自己的SH私钥对自己发送的消息进行签名,然后将签名生成的数据
放到要发送的消息内,然后对整个消息用PT公钥进行加密(或者部分消息进行加密)。
(3)SH发送消息到PT, 然后PT首先使用手中的PT私钥,对消息进行解密,然后拿到其中的签名信息,
并用SH公钥进行验证签名。然后进行相应操作后
PT发送请求异步回调消息
(一)PT使用PT私钥,对要进行发送的消息进行签名,然后将消息使用SH公钥进行加密,然后发送给SH。
(二)SH接收到PT的消息后,首先使用SH私钥进行解密,然后获取到其中的签名信息,
然后使用PT公钥进行验签。如果没有问题处理下面的过程.
(三)SH根据获取到的消息,进行相应的返回,SH使用SH私钥进行签名,然后用PT公钥进行加密,
发送给PT,PT收到消息之后,首先用PT私钥进行解密,获取签名数据后,使用PT公钥进行验签。
可用工具类:
package com.oumasoft.web.test;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Map;
import java.util.TreeMap;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
public class RSATest {
/**
* * RSA最大加密明文大小
*
*/
private static final int MAX_ENCRYPT_BLOCK = 117;
/**
* RSA最大解密密文大小
*/
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* 获取秘钥对 生成啥秘钥对?
* @return
* @throws Exception
*/
public static KeyPair getKeyPair() throws Exception {
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
generator.initialize(1024);
return generator.generateKeyPair();
}
/**
* 根据已知Base64后的私钥字符串 获取私钥
* @param privateKey
* @return
*
Interfaces KeySpec
-java.security.spec.EncodedKeySpec (实现这个接口)
-java.security.spec.PKCS8EncodedKeySpec 该类代表私有密钥的ASN.1编码,根据ASN.1类型PrivateKeyInfo进行编码
-java.security.spec.X509EncodedKeySpec 该类表示公钥的ASN.1编码,根据ASN.1类型SubjectPublicKeyInfo进行编码。
-java.security.spec.RSAPrivateKeySpec
Interfaces Key
Interface - PrivateKey extends Key, Destroyable
Interface - RSAPrivateKey extends PrivateKey, RSAKey
* @throws Exception
*/
public static PrivateKey getPrivateKey(String privateKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");//单例模式 返回一个KeyFactory对象,它转换指定RSA算法的公钥/私钥。
byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());//进行base64解码
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);//使用给定的编码密钥创建一个新的PKCS8EncodedKeySpec,decodedKey假设按照PKCS#8标准进行编码的密钥。 复制数组的内容以防止后续修改。。
return keyFactory.generatePrivate(keySpec);//generatePrivate(KeySpec keySpec) 从提供的密钥规范(密钥材料)生成私钥对象。
}
/**
* 获取公钥
* @param publicKey 公钥字符串
* @return
Interfaces Key
Interface - PublicKey extends extends Key
Interface - RSAPrivateKey extends PublicKey, RSAKey
* @throws Exception
*/
public static PublicKey getPublicKey(String publicKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");//获取单例模式的对象
byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());//进行base64编码
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
return keyFactory.generatePublic(keySpec);
}
/**
* RSA加密
*
* @param data 待加密数据,可能包含了已经进行签名的内容
* @param publicKey 公钥
* @return
*/
public static String RSAEncrypt(String data, PublicKey publicKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");//该类提供加密和解密的加密密码的功能。 它构成了Java加密扩展(JCE)框架的核心。
cipher.init(Cipher.ENCRYPT_MODE, publicKey);//用密钥初始化此密码。
int inputLen = data.getBytes().length;//获取长度
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(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);//在单一部分操作中加密或解密数据,或完成多部分操作。
} else {
cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
}
out.write(cache, 0, cache.length);
i++;
offset = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
// 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
// 加密后的字符串
return new String(Base64.encodeBase64String(encryptedData));
}
/**
* RSA解密
* @param data 待解密数据
* @param privateKey 私钥
* @return
*/
public static String RSADecrypt(String data, PrivateKey privateKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] dataBytes = Base64.decodeBase64(data);
int inputLen = dataBytes.length;
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(dataBytes, offset, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
}
out.write(cache, 0, cache.length);
i++;
offset = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
out.close();
// 解密后的内容
return new String(decryptedData, "UTF-8");
}
/**
* 签名
*
* @param data
* 待签名数据
* @param privateKey
* 私钥
* @return 签名
*/
public static String sign(String data, PrivateKey privateKey) throws Exception {
byte[] keyBytes = privateKey.getEncoded();
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey key = keyFactory.generatePrivate(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(key);
signature.update(data.getBytes());
return new String(Base64.encodeBase64(signature.sign()));
}
/**
* 验签
*
* @param srcData
* 原始字符串
* @param publicKey
* 公钥
* @param sign
* 签名
* @return 是否验签通过
*/
public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
byte[] keyBytes = publicKey.getEncoded();
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey key = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initVerify(key);
signature.update(srcData.getBytes());
return signature.verify(Base64.decodeBase64(sign.getBytes()));
}
public static String getSignStr(TreeMap<String,String> params) {
if(params.containsKey("sign"))//签名明文组装不包含sign字段
params.remove("sign");
StringBuilder sb = new StringBuilder();
for(Map.Entry<String, String> entry:params.entrySet()){
if(entry.getValue()!=null&&entry.getValue().length()>0){
sb.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
}
}
if(sb.length()>0){
sb.deleteCharAt(sb.length()-1);
}
return sb.toString();
}
public static void main(String[] args) {
try {
TreeMap<String,String> params = new TreeMap<String,String>();
params.put("PARAM1","remarkparam");
params.put("INIP","127.0.0.1");
params.put("STYLE","01");
params.put("ORDNUM","D15082500000002");
params.put("SERVICE","com.bs.pay");
params.put("ORDDATE","20150825");
String signStr = getSignStr(params);
//System.out.println("signStr="+signStr);
//String str2Sign="INIP=127.0.0.1&ORDDATE=20150825&ORDNUM=D15082500000002&PARAM1=remarkparam&SERVICE=com.bs.pay&STYLE=01";
// 生成密钥对
//KeyPair keyPair = getKeyPair();
String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKstf0WW7CXfXHbk137gKVolqeJLwNPMWYzpfvGXFt0PnfqNbVq0FFt3qZIXfeW9s1bBFLeV12vps99/1EfSj82vBVahEHPsPuLFh/oJ6pm1i4H2tvLVM34GWQpK7G6S/y9ldw8jAZHXXte/39+64XGUNngrQPrPPUGAMbiG6lHbAgMBAAECgYAvWgGX7XzbqSL53Knj9fxabIrHB6+Kpz+qZDjyeZoggp5v3cl/SstK1ho5SHhSIhzHBdhGRJP3zQkt7T16tLuEdQE0oR4h+RPXhtpFVXzApS6xnGP3K0IKfnIt5+48Lz0n5eEZ8CLlioJeSmIJxmD/LBeFGU/+ycQNuTho6+nfWQJBAORqUlGWx3K+df9+kPA75KS5xcSWFl+C3h9IKApjYCb6Pgyj4+VSKRpUmk1aRiU3FP5zA64hpr/9dHJzurluLTUCQQC/2Z7YqhRNs2vnAx/CV7vqUhHlJYNhlCHESl2RxYj4uwDPGkG34HEe3yjcxyXCFE3MjrI6bW4omUPOvxOksTTPAkBtSqpEu76HGrbfHzI+oInQf8svOxlNbhLWKPJvtgkF3WrfJXQf/+YG4UBLjsxNdkOnVGUIZrWg26diNBm+LAeZAkBdEoRfdFOZRnwIfJmBvPJrQRlxY3uTcTvYcINoXr6OfJpt3r0XKYl3gqfeQ7brqtH7dRa+Bay1gXVF7ajn8xg9AkAjmPZxgfllYW9uRojFzH91bkCHK7f41nocWPPkax3wkCjMtKisUXL+2B1Hgr9U9Zp6naNbw/43xNRSVSXQg8IW";
String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrLX9Fluwl31x25Nd+4ClaJaniS8DTzFmM6X7xlxbdD536jW1atBRbd6mSF33lvbNWwRS3lddr6bPff9RH0o/NrwVWoRBz7D7ixYf6CeqZtYuB9rby1TN+BlkKSuxukv8vZXcPIwGR117Xv9/fuuFxlDZ4K0D6zz1BgDG4hupR2wIDAQAB";
//String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
//System.out.println("私钥:" + privateKey);
//System.out.println("公钥:" + publicKey);
// RSA加密
//String data = "待加密的文字内容";
String encryptData = RSAEncrypt(signStr, getPublicKey(publicKey));
System.out.println("加密后内容:" + encryptData);
// RSA解密
String decryptData = RSADecrypt(encryptData, getPrivateKey(privateKey));
System.out.println("解密后内容:" + decryptData);
// RSA签名
String sign = sign(signStr, getPrivateKey(privateKey));
System.out.println("sign=="+sign);
// RSA验签
boolean result = verify(signStr, getPublicKey(publicKey), sign);
System.out.print("验签结果:" + result);
} catch (Exception e) {
e.printStackTrace();
System.out.print("加解密异常");
}
}
}