RSA加密和解密

RSA是一种非对称加密算法.RSA有两个密钥，一个是公开的，称为公开密钥；一个是私密的，称为私密密钥。公开密钥是对大众公开的，私密密钥是服务器私有的，两者不能互推得出。用公开密钥对数据进行加密，私密密钥可解密；私密密钥对数据加密，公开密钥可解密。

一、工具类

import java.io.IOException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
 
 
public class RSAUtil {
    
    
    //生成秘钥对
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512); //长度可更改  512 1024 2048 4096
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
    }
    
    //获取公钥(Base64编码)
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return byte2Base64(bytes);
    }
    
    //获取私钥(Base64编码)
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return byte2Base64(bytes);
    }
    
    //将Base64编码后的公钥转换成PublicKey对象
    public static PublicKey string2PublicKey(String pubStr) throws Exception{
        byte[] keyBytes = base642Byte(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
    
    //将Base64编码后的私钥转换成PrivateKey对象
    public static PrivateKey string2PrivateKey(String priStr) throws Exception{
        byte[] keyBytes = base642Byte(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
    
    //公钥加密
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
    
    //私钥解密
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
    
    //字节数组转Base64编码
    public static String byte2Base64(byte[] bytes){
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(bytes);
    }
    
    //Base64编码转字节数组
    public static byte[] base642Byte(String base64Key) throws IOException{
        BASE64Decoder decoder = new BASE64Decoder();
        return decoder.decodeBuffer(base64Key);
    }
}

二、测试类

import static org.junit.Assert.*;

import org.junit.Test;

import com.sino.nms.gpon.serviceImpl.SinoLicenseTimeServiceImpl;
import com.sino.nms.otn.utils.RSAUtil;
import com.sino.nms.struts.gpon.bean.User;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
 
 
public class RSA {
 
    @Test
    public void testRSA(){
        try {
            //===============生成公钥和私钥，公钥传给客户端，私钥服务端保留==================
//            生成RSA公钥和私钥，并Base64编码
            KeyPair keyPair = RSAUtil.getKeyPair();
            String publicKeyStr = RSAUtil.getPublicKey(keyPair);
            String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
            System.out.println("RSA公钥Base64编码:" + publicKeyStr);
            System.out.println("RSA私钥Base64编码:" + privateKeyStr);
//            String publicKeyStr = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAK6RG8dNlCP5Jhksr/r3A4Zqm2yPAa+HUDEkXANvos48of7IelwenZBfjXTeZShKrYdyIfAosyU7jkb/4FOmBTMCAwEAAQ==";
//            String privateKeyStr = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEArpEbx02UI/kmGSyv+vcDhmqbbI8B
"
//+"r4dQMSRcA2+izjyh/sh6XB6dkF+NdN5lKEqth3Ih8CizJTuORv/gU6YFMwIDAQABAkAuEf3Sy5ad
"
//+"J9P2MOUAxtAXWWtLazJ2sK9pSL8/6OZ+pvJERzNyygSW7FQrLrRcdYljHw+tn1uJDcfz5B0CozUB
"
//+"AiEA1I5sVwILBIzPBTsJ3/CFdIBQAtfApRlgr5RFChufpYkCIQDSPvYxLR5h0kr6+KmpwmYsHI8E
"
//+"Ja66UzxshvoNxWbh2wIhAMWgnm7PgXr7iMguOmIyeYL2gm4COCXJULIvQ3nAcVExAiBIovwHjWD7
"
//+"xt2ky5hCUClggBVhB2vQb8VmcVOewl6DFQIhAI3MJY/xoPqqBbw2cHSXR+iFOYBdumpRLB4GvOUR
"
//+"isaP";
//            System.out.println("RSA公钥Base64编码:" + publicKeyStr);
//            System.out.println("RSA私钥Base64编码:" + privateKeyStr);
            
            //=================客户端=================
            //public 加密
            String message = "public";
            //将Base64编码后的公钥转换成PublicKey对象
            PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStr);
            //用公钥加密
            byte[] publicEncrypt = RSAUtil.publicEncrypt(message.getBytes(), publicKey);
            //加密后的内容Base64编码
            String byte2Base64 = RSAUtil.byte2Base64(publicEncrypt);
//            String byte2Base64 = "fcqRB2XPu53meL8dgXFlmv2NBGaZ62JfmExu5KVao4Epr6Q5P0vKOddW6T/cDYtCkKYhQsY06u70XNoUrS34Rg==";
            System.out.println("公钥加密并Base64编码的结果：" + byte2Base64);
            
            
            //##############    网络上传输的内容有Base64编码后的公钥 和 Base64编码后的公钥加密的内容     #################
            
            //===================服务端================
            //将Base64编码后的私钥转换成PrivateKey对象
            PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKeyStr);
            //加密后的内容Base64解码
            byte[] base642Byte = RSAUtil.base642Byte(byte2Base64);
            //用私钥解密
            byte[] privateDecrypt = RSAUtil.privateDecrypt(base642Byte, privateKey);
            //解密后的明文
            System.out.println("解密后的明文: " + new String(privateDecrypt));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
 
}