RSA加密算法浅析

一、简介

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("加解密异常");
        }
    }
}