RSA加密工具类（非对称加密算法）

import com.jfinal.log.Log;
import org.apache.commons.codec.binary.Base64;import javax.crypto.Cipher;
import java.security.*;
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;/**
 * RSA安全编码组件
 */
public abstract class ToolRSA {    private static final Log log = Log.getLog(ToolRSA.class);    /**
     * 非对称加密密钥算法
     */
    public static final String KEY_ALGORITHM = "RSA";    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";    /**
     * 私钥
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";    /**
     * RSA密钥长度 默认1024位， 密钥长度必须是64的倍数， 范围在512至65536位之间。
     */
    private static final int KEY_SIZE = 512;    /**
     * 私钥解密
     *
     * @param data 待解密数据
     * @param key  私钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.DECRYPT_MODE, privateKey);        return cipher.doFinal(data);
    }    /**
     * 公钥解密
     *
     * @param data 待解密数据
     * @param key  公钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        // 生成公钥
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.DECRYPT_MODE, publicKey);        return cipher.doFinal(data);
    }    /**
     * 公钥加密
     *
     * @param data 待加密数据
     * @param key  公钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.ENCRYPT_MODE, publicKey);        return cipher.doFinal(data);
    }    /**
     * 私钥加密
     *
     * @param data 待加密数据
     * @param key  私钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());        cipher.init(Cipher.ENCRYPT_MODE, privateKey);        return cipher.doFinal(data);
    }    /**
     * 取得私钥
     *
     * @param keyMap 密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }    /**
     * 取得公钥
     *
     * @param keyMap 密钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }    /**
     * 初始化密钥
     *
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        // 实例化密钥对生成器
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);        // 初始化密钥对生成器
        keyPairGen.initialize(KEY_SIZE);        // 生成密钥对
        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;
    }    //获得base64加密的公钥字符串
    public static String getPublicKeyStr(Map<String, Object> keyMap) throws Exception {
        //获得map中的公钥对象 转为key对象
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        //编码返回字符串
        return Base64.encodeBase64String(key.getEncoded());
    }    //获得base64加密的私钥字符串
    public static String getPrivateKeyStr(Map<String, Object> keyMap) throws Exception {
        //获得map中的私钥对象 转为key对象
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        //编码返回字符串
        return Base64.encodeBase64String(key.getEncoded());
    }    //还原byte数组的公钥
    public static byte[] getPublicKeyByte(String publicKeyStr) {
        return Base64.decodeBase64(publicKeyStr);
    }    //还原byte数组的私钥
    public static byte[] getPrivateKeyByte(String privateKeyStr) {
        return Base64.decodeBase64(privateKeyStr);
    }    public static void main(String[] args) {
        try {
            String dataStr = "今天天气很好";
            Map<String, Object> keyMap = initKey();//初始化公钥和私钥
            byte[] publicKey = getPublicKey(keyMap);
            byte[] privateKey = getPrivateKey(keyMap);            //利用base64生成String字符串的公钥和私钥
            String publicKeyStr = Base64.encodeBase64String(publicKey);//生成字符串公钥
            byte[] publicKey2 = Base64.decodeBase64(publicKeyStr);//base64还原了公钥publicKey
            String privateKeyStr = Base64.encodeBase64String(privateKey);//生成字符串私钥
            byte[] privateKey2 = Base64.decodeBase64(privateKeyStr);//base64还原了私钥privateKey

String gStr = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALni7Ge9AHPZKSIAaMmB5dh/3852ZyKWPQIe0VRU3xnymOI7+3XX3tXMMiH7xOYLG7YucaEPm9gUJYS8PFhOGU8CAwEAAQ==";
String pStr = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAueLsZ70Ac9kpIgBoyYHl2H/fznZnIpY9Ah7RVFTfGfKY4jv7ddfe1cwyIfvE5gsbti5xoQ+b2BQlhLw8WE4ZTwIDAQABAkEAl/U4+wkXwJyrMn+RKgHFqrnGdNp4L18QGpak20LSaztwDRUgDhYzGh6HEDhQNB+UG5v+RV2ZYCPuQvUlUjWImQIhAOxoXBGTbw8MbylCur7jOu/N0kEa8TfwDixLShWw64ozAiEAyUqztCQtaT8ZUd9DAl4oOJVucEoLwr5TdRH14RCoUHUCIFakbNHYOgTG5tq1ZSHev9PxmBRaXnvE1DzxnwZSIBE3AiEAvkGVSRdItMmnLPNRatOEQLc9A3V5WEB8sZKgTHJqJGECIHP5aL2buJBVbBMgn8f5wD11TPBKW1ZU9XZrCjGM0Hiw";

            byte[] beforData = encryptByPublicKey(dataStr.getBytes(), publicKey);
            log.info(new String(beforData));
            byte[] afterData = decryptByPrivateKey(beforData, privateKey);
            log.info(new String(afterData));        } catch (Exception e) {
            e.printStackTrace();
        }    }

private void test() {
    try {
        String password = "k4UUA7/bME/EgFUdNE+syvPX88rm2uFJonOP+7ekqbW0Vrz7lUA2zpw3wP+yKlPgc9xGXJKorBvYQ4F8n6EwXw==";//前台传入
        String username = "IxpcxKe9D6w6aeNVwQAYtL6btjueTK44fmIt4yCq+Rlc3VxxvJLEKI814LkhvQTalduSKr3NMSAn5Wdl7hUc1Q==";//前台传入
        String privateKeyStr = "MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAueLsZ70Ac9kpIgBoyYHl2H/fznZnIpY9Ah7RVFTfGfKY4jv7ddfe1cwyIfvE5gsbti5xoQ+b2BQlhLw8WE4ZTwIDAQABAkEAl/U4+wkXwJyrMn+RKgHFqrnGdNp4L18QGpak20LSaztwDRUgDhYzGh6HEDhQNB+UG5v+RV2ZYCPuQvUlUjWImQIhAOxoXBGTbw8MbylCur7jOu/N0kEa8TfwDixLShWw64ozAiEAyUqztCQtaT8ZUd9DAl4oOJVucEoLwr5TdRH14RCoUHUCIFakbNHYOgTG5tq1ZSHev9PxmBRaXnvE1DzxnwZSIBE3AiEAvkGVSRdItMmnLPNRatOEQLc9A3V5WEB8sZKgTHJqJGECIHP5aL2buJBVbBMgn8f5wD11TPBKW1ZU9XZrCjGM0Hiw";
        byte[] privateKey = Base64.decodeBase64(privateKeyStr);//base64还原了私钥privateKey        byte[] password2 = decryptByPrivateKey(Base64.decodeBase64(password), privateKey);
        log.info(new String(password2));//fxgk@321
        byte[] username2 = decryptByPrivateKey(Base64.decodeBase64(username), privateKey);
        log.info(new String(username2));//P31170774
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、前端加密如要引入

jsencrypt.min.js
下载地址：http://travistidwell.com/jsencrypt/
该文件在解压后的bin目录下；

var username = $("#username").val();
var password = $("#password").val();
// 密钥加密
var publicKey = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALni7Ge9AHPZKSIAaMmB5dh/3852ZyKWPQIe0VRU3xnymOI7+3XX3tXMMiH7xOYLG7YucaEPm9gUJYS8PFhOGU8CAwEAAQ==";
var encrypt = new JSEncrypt();
encrypt.setPublicKey(publicKey);
password = encrypt.encrypt(password);var encrypt = new JSEncrypt();
encrypt.setPublicKey(publicKey);
username = encrypt.encrypt(username);

个人收藏笔记记录

开通VIP