javaweb项目使用RSA算法

1. RSA算法介绍

RSA算法是一种非对称算法，即是加密的密码和解密的密码是不一致的。因此对RSA的加密和加密的密码分为公钥和私钥。根据RSA的算法介绍，只要密钥的长度足够长，现在没有任何方法可以破解。而且这个算法的专利已经在2000年9月21日失效，因此应该是可以任意使用的。

密钥获取：

选用PKCS#8生成密钥，选PKCS#1可能会导致解密失败

http://web.chacuo.net/netrsakeypair

1. javaweb使用RSA

1.1. 前端加密

要在前端加密密码，就要使用到jsencrypt的js

1.1.1. jsencrypt下载

官网：http://travistidwell.com/jsencrypt/

github: https://github.com/travist/jsencrypt/releases

在bin目录下面可以找到相关js：

1.1.2. 代码示例

 1 //RSA加密
 2 function encryptRequest(reqUrl, data) {
 3     var publicKey = "****";
 4     var encrypt = new JSEncrypt();
 5     encrypt.setPublicKey(publicKey);
 6 // ajax请求发送的数据对象 
 7 var password = ‘xxxx’;
 8     // 将data数组赋给ajax对象 
 9 password  = encrypt.encrypt(password ); 
10  $.ajax({
11         type: 'post',
12         url: reqUrl,
13         data: password,
14         async:false, 
15         success: function(data){  
16                 return false;
17         }
18         error : function(XMLResponse) {
19             var msg = XMLResponse.responseText;
20             console.log(msg);
21         }
22     });
23 }

1.1. 后端解密

1.1.1. 相关工具类准备

1.1.1.1. Base64Utils

Base64工具类，可以让rsa编码的乱码变成一串字符序列

  1 package cn.sinobest.common.misc;
  2  
  3 import java.io.ByteArrayInputStream;
  4 import java.io.ByteArrayOutputStream;
  5 import java.io.File;
  6 import java.io.FileInputStream;
  7 import java.io.FileOutputStream;
  8 import java.io.InputStream;
  9 import java.io.OutputStream;
 10 
 11 import org.apache.commons.codec.binary.Base64;
 12  
 13 
 14 /** */
 15 /**
 16  * <p>
 17  * BASE64编码解码工具包
 18  * </p>
 19  * <p>
 20  * 依赖javabase64-1.3.1.jar
 21  * </p>
 22  *  
 23  * @date 2012-5-19
 24  * @version 1.0
 25  */
 26 public class Base64Utils {
 27 
 28     /** */
 29     /**
 30      * 文件读取缓冲区大小
 31      */
 32     private static final int CACHE_SIZE = 1024;
 33 
 34     /** */
 35     /**
 36      * <p>
 37      * BASE64字符串解码为二进制数据
 38      * </p>
 39      * 
 40      * @param base64
 41      * @return
 42      * @throws Exception
 43      */
 44     public static byte[] decode(String base64str) throws Exception {
 45         Base64 base64 = new Base64();
 46         return base64.decode(base64str.getBytes());
 47     }
 48 
 49     /** */
 50     /**
 51      * <p>
 52      * 二进制数据编码为BASE64字符串
 53      * </p>
 54      * 
 55      * @param bytes
 56      * @return
 57      * @throws Exception
 58      */
 59     public static String encode(byte[] bytes) throws Exception {
 60         Base64 base64 = new Base64();
 61         return new String(base64.encode(bytes));
 62     }
 63 
 64     /** */
 65     /**
 66      * <p>
 67      * 将文件编码为BASE64字符串
 68      * </p>
 69      * <p>
 70      * 大文件慎用，可能会导致内存溢出
 71      * </p>
 72      * 
 73      * @param filePath
 74      *            文件绝对路径
 75      * @return
 76      * @throws Exception
 77      */
 78     public static String encodeFile(String filePath) throws Exception {
 79         byte[] bytes = fileToByte(filePath);
 80         return encode(bytes);
 81     }
 82 
 83     /** */
 84     /**
 85      * <p>
 86      * BASE64字符串转回文件
 87      * </p>
 88      * 
 89      * @param filePath
 90      *            文件绝对路径
 91      * @param base64
 92      *            编码字符串
 93      * @throws Exception
 94      */
 95     public static void decodeToFile(String filePath, String base64) throws Exception {
 96         byte[] bytes = decode(base64);
 97         byteArrayToFile(bytes, filePath);
 98     }
 99 
100     /** */
101     /**
102      * <p>
103      * 文件转换为二进制数组
104      * </p>
105      * 
106      * @param filePath
107      *            文件路径
108      * @return
109      * @throws Exception
110      */
111     public static byte[] fileToByte(String filePath) throws Exception {
112         byte[] data = new byte[0];
113         File file = new File(filePath);
114         if (file.exists()) {
115             FileInputStream in = new FileInputStream(file);
116             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
117             byte[] cache = new byte[CACHE_SIZE];
118             int nRead = 0;
119             while ((nRead = in.read(cache)) != -1) {
120                 out.write(cache, 0, nRead);
121                 out.flush();
122             }
123             out.close();
124             in.close();
125             data = out.toByteArray();
126         }
127         return data;
128     }
129 
130     /** */
131     /**
132      * <p>
133      * 二进制数据写文件
134      * </p>
135      * 
136      * @param bytes
137      *            二进制数据
138      * @param filePath
139      *            文件生成目录
140      */
141     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
142         InputStream in = new ByteArrayInputStream(bytes);
143         File destFile = new File(filePath);
144         if (!destFile.getParentFile().exists()) {
145             destFile.getParentFile().mkdirs();
146         }
147         destFile.createNewFile();
148         OutputStream out = new FileOutputStream(destFile);
149         byte[] cache = new byte[CACHE_SIZE];
150         int nRead = 0;
151         while ((nRead = in.read(cache)) != -1) {
152             out.write(cache, 0, nRead);
153             out.flush();
154         }
155         out.close();
156         in.close();
157     }
158 
159 }

1.1.1.1. RsaUtil

RsaUtil工具类，可以调用里面的方法，产生公钥私钥对，和采用公钥加密，私钥加密等

package cn.sinobest.common.misc;
 
import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
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.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/** */
/**
 * <p>
 * RSA公钥/私钥/签名工具包
 * </p>
 * <p>
 * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
 * </p>
 * <p>
 * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
 * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
 * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
 * </p>
 *   
 * @version 1.0
 */
public class RSAUtils {

    /** */
    /**
     * 加密算法RSA
     */
    public static final String KEY_ALGORITHM = "RSA";

    /** */
    /**
     * 签名算法
     */
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

    /** */
    /**
     * 获取公钥的key
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /** */
    /**
     * 获取私钥的key
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /** */
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** */
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    /** */
    /**
     * <p>
     * 生成密钥对(公钥和私钥)
     * </p>
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> genKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        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);
        return keyMap;
    }

    /** */
    /**
     * <p>
     * 用私钥对信息生成数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * 
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateK);
        signature.update(data);
        return Base64Utils.encode(signature.sign());
    }

    /** */
    /**
     * <p>
     * 校验数字签名
     * </p>
     * 
     * @param data
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @param sign
     *            数字签名
     * 
     * @return
     * @throws Exception
     * 
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64Utils.decode(sign));
    }

    /** */
    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.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(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.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(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.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, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.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, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 获取私钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /** */
    /**
     * <p>
     * 获取公钥
     * </p>
     * 
     * @param keyMap
     *            密钥对
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Utils.encode(key.getEncoded());
    }

    /**
     * java端公钥加密
     */
    public static String encryptedDataOnJava(String data, String PUBLICKEY) {
        try {
            data = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return data;
    }

    /**
     * java端私钥解密
     */
    public static String decryptDataOnJava(String data, String PRIVATEKEY) {
        String temp = "";
        try {
            byte[] rs = Base64Utils.decode(data);
            temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8"); //以utf-8的方式生成字符串

        } catch (Exception e) {
            e.printStackTrace();
        }
        return temp;
    }

}

1.1.1. 后端实例

1 public class TestAction {
2     private static final String PrivateKey = "***";
3     
4     public void test(String password) {
5         password = RSAUtils.decryptDataOnJava(password, PrivateKey);
6         System.out.println("密码是："+password);
7     }
8 }

该文档参考以下两篇文章：

https://www.cnblogs.com/Leo_wl/p/5763243.html
https://www.cnblogs.com/nanyangke-cjz/p/5898361.html