加密算法使用（五）：RSA使用全过程

RSA是一种非对称加密算法，使用RSA前先生成一对公钥和私钥。

使用公钥加密的数据可以用私钥解密，同样私钥加密的数据也可以用公钥解密，

不同之处在于，私钥加密数据的同时还可以生成一组签名，签名是用来验证数据是否在传输过程中有变动的，使用公钥、签名、以及公钥加密后的数据，就可以验证是否有变动，当然也可以不验证。

代码示例如下，两个main方法：main和main1。加密解密都是针对byte数组的，考虑到我们实际使用的时候大部分场景应该是用字符串来传递数据，所以演示代码中频繁的将byte数组转化为字符串，有些byte数组不是从字符串直接转化来的，直接通过new String的方式转字符串会出现乱码，所以用到了Base64来解决这一问题。

另外，演示代码为了方便看到全过程，基本上没有抽出方法，实际使用的时候建议重构一下。

说明就到此为止，代码如下：

package testEncrypt;

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;

/**
 * 
 * @ClassName: TestRsaEncrypt
 * @Description: TODO
 * @author: liuyx
 * @date: 2016年4月28日上午10:20:59
 */
public class TestRsaEncrypt {
    public static final String KEY_ALGORITHM = "RSA";  
    private static final String PUBLIC_KEY = "RSAPublicKey";  
    private static final String PRIVATE_KEY = "RSAPrivateKey";  
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    private static KeyFactory keyFactory = null;
    static {
        try {
            keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    //公钥加密 私钥解密
    public static void main(String[] args) throws Exception {
        //生成密钥对
        
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(512);  
  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        // 公钥  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
  
        // 私钥  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey); 
        
        String publicKeyStr = getBase64KeyEncodeStrFromKey(publicKey);
        String privateKeyStr = getBase64KeyEncodeStrFromKey(privateKey);
        System.out.println("公钥:"+publicKeyStr);
        System.out.println("私钥:"+privateKeyStr);
        
        //数据加密过程演示
        System.out.println("公钥加密——私钥解密");  
        
        //要加密的数据
        String dataStr = "abcdefghhhhhhhopqrst";
        System.out.println("要加密的数据:"+dataStr);
        byte[] data = dataStr.getBytes();
        
        
        // 对公钥解密  
        Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKeyStr);  
  
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);  
        cipher.init(Cipher.ENCRYPT_MODE, decodePublicKey);  
        byte[] encodedData = cipher.doFinal(data); 
        String encodedDataStr = Base64.encodeBase64String(encodedData);
        System.out.println("公钥加密后的数据:"+encodedDataStr);
        
        //对私钥解密
        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKeyStr);
        cipher.init(Cipher.DECRYPT_MODE, decodePrivateKey); 
        encodedData = Base64.decodeBase64(encodedDataStr);
        byte[] decodedData = cipher.doFinal(encodedData); 
        String decodedDataStr = new String(decodedData);
        System.out.println("私钥解密后的数据:"+decodedDataStr);
    }
    
    //私钥加密 公钥解密,附带签名验证过程
    public static void main1(String[] args) throws Exception {
        //生成密钥对
        
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
        keyPairGen.initialize(512);  
  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
  
        // 公钥  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
  
        // 私钥  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
  
        Map<String, Object> keyMap = new HashMap<String, Object>(2);  
  
        keyMap.put(PUBLIC_KEY, publicKey);  
        keyMap.put(PRIVATE_KEY, privateKey); 
        
        String publicKeyStr = getBase64KeyEncodeStrFromKey(publicKey);
        String privateKeyStr = getBase64KeyEncodeStrFromKey(privateKey);
        System.out.println("公钥:"+publicKeyStr);
        System.out.println("私钥:"+privateKeyStr);
        
        //数据加密过程演示
        System.out.println("私钥加密——公钥解密");  
        
        //要加密的数据
        String dataStr = "abcdefghhhhhhhopqrst1";
        System.out.println("要加密的数据:"+dataStr);
        byte[] data = dataStr.getBytes();
        
        //对私钥解密
        Key decodePrivateKey = getPrivateKeyFromBase64KeyEncodeStr(privateKeyStr);
        //对公钥解密  
        Key decodePublicKey = getPublicKeyFromBase64KeyEncodeStr(publicKeyStr);  
  
        // 对数据加密  
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);  
        cipher.init(Cipher.ENCRYPT_MODE, decodePrivateKey);  
        byte[] encodedData = cipher.doFinal(data); 
        
        //插曲，加密后的数据+私钥，生成签名，验证签名
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
        signature.initSign((PrivateKey)decodePrivateKey);  //用的是私钥
        signature.update(encodedData);  //用的是加密后的数据字节数组
  
        //取得签名
        String sign = Base64.encodeBase64String((signature.sign())); 
        
        //初始化验证签名
        signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify((PublicKey )decodePublicKey);  //用的是公钥
        signature.update(encodedData);  //用的是加密后的数据字节数组
        
        //实际的验证过程，获取验证结果
        boolean ret = signature.verify(Base64.decodeBase64(sign));
        System.out.println("验证结果:"+ret);
        //插曲结束
        
        
        String encodedDataStr = Base64.encodeBase64String(encodedData);
        System.out.println("私钥加密后的数据:"+encodedDataStr);
        
        
        
        cipher.init(Cipher.DECRYPT_MODE, decodePublicKey); 
        encodedData = Base64.decodeBase64(encodedDataStr);
        byte[] decodedData = cipher.doFinal(encodedData); 
        String decodedDataStr = new String(decodedData);
        System.out.println("公钥解密后的数据:"+decodedDataStr);
        
    }
    
    /*
     * 获取key的base64加密后的字符串
     */
    private static String getBase64KeyEncodeStrFromKey(Key key) {
        return Base64.encodeBase64String(key.getEncoded());
    }
    
    /*
     * 获取base64加密后的字符串的原始公钥
     */
    private static Key getPublicKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.decodeBase64(keyStr);  
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
        Key publicKey = null;
        try {
            publicKey = keyFactory.generatePublic(x509KeySpec);  
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  
        return publicKey;
    }
    
    private static Key getPrivateKeyFromBase64KeyEncodeStr(String keyStr) {
        byte[] keyBytes = Base64.decodeBase64(keyStr); 
        // 取得私钥  
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  

        Key privateKey=null;
        try {
            privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        } catch (InvalidKeySpecException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  
        return privateKey;
    }
}