rsa加密算法，前后端实现。

前端js:

　　下载地址：http://travistidwell.com/jsencrypt/

js第一版本：

// 对数据加密
    function encrypt(enStr){
        //没有加载jsencrypt.js
        if(typeof(JSEncrypt) != "function"){
            return enStr;
        } 
        if(!window.rsa){    
            window.rsa = new JSEncrypt();
            window.rsa.setPublicKey("MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgHz+GrcnJ4w246LUsKeodDYKEQW2tUHvneYETB4/WtCWNJNH9A4NXJOKrF5eXtGB6hWw6DfkBrNawQi13Cok30HGAGOsqNC3TrG+lFH/MdnIFLc0bc4SNKy0aL6h9Og+OnEfqyGe9hBmviVkYVONMwXAM+mkd74ZEEw1rlTodKf9AgMBAAE=");
        }
        
        var result = window.rsa.encrypt(enStr);
        // 加密失败返回原数据
        if(result === false){
            return enStr;
        }
        return JSON.stringify(result);
    }

ps：经测试发现，rsa最多只能对117个字节进行加密。超过117个字节就会加密失败。

js第二版本：

思路：若超过117个字节，就切分开分别进行加密。

// 对数据分段加密
    function segmentEncrypt(enStr){
        if(typeof(JSEncrypt) === "function"){
            if(!window.rsa){    
                window.rsa = new JSEncrypt();
                window.rsa.setPublicKey("MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgHz+GrcnJ4w246LUsKeodDYKEQW2tUHvneYETB4/WtCWNJNH9A4NXJOKrF5eXtGB6hWw6DfkBrNawQi13Cok30HGAGOsqNC3TrG+lFH/MdnIFLc0bc4SNKy0aL6h9Og+OnEfqyGe9hBmviVkYVONMwXAM+mkd74ZEEw1rlTodKf9AgMBAAE=");
            }
        }else{
            return enStr;
        } 
        
        var result = [],
            offSet = 0,
            cache = '',
            i = 1,
            inputLen = enStr.length;
        
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > 117) {
                cache = window.rsa.encrypt(enStr.substring(offSet, 117 * i));
            } else {
                cache = window.rsa.encrypt(enStr.substring(offSet));
            }
            // 加密失败返回原数据
            if(cache === false){
                return enStr;
            }
            offSet = i++ * 117;
            
            result.push(cache);
        }
        return JSON.stringify(result);
    }

java代码：

package com.test.utils;

import java.io.ByteArrayOutputStream;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
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;

import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class RSAUtil {
    private static Logger logger = LoggerFactory.getLogger(RSAUtil.class);    //日志记录
    private static final String KEY_ALGORITHM = "RSA";
    
    //临时使用
    public static final String RSA_PUB_KEY = "MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgHz+GrcnJ4w246LUsKeodDYKEQW2
tUHvneYETB4/WtCWNJNH9A4NXJOKrF5eXtGB6hWw6DfkBrNawQi13Cok30HGAGOs
qNC3TrG+lFH/MdnIFLc0bc4SNKy0aL6h9Og+OnEfqyGe9hBmviVkYVONMwXAM+mk
d74ZEEw1rlTodKf9AgMBAAE=";
    public static final String RSA_PRI_KEY = "MIICWgIBAAKBgHz+GrcnJ4w246LUsKeodDYKEQW2tUHvneYETB4/WtCWNJNH9A4N
XJOKrF5eXtGB6hWw6DfkBrNawQi13Cok30HGAGOsqNC3TrG+lFH/MdnIFLc0bc4S
NKy0aL6h9Og+OnEfqyGe9hBmviVkYVONMwXAM+mkd74ZEEw1rlTodKf9AgMBAAEC
gYAv3vJEa06OOQd9+Y+e5rl7aOeUFKHfGvKSgdrVStZxRNXmAozKRPvL1jSl/+a4
vtT0cci+fyrBzmRX/a7QxUZr1ROryeqv/DLnz8b1fXbIIXfO0MiNniytG0qzEHda
Vxof3reibaHLCL6wM266qgTVd2FMo8igATUgWvpMS/xuAQJBAMBcyxa/Vv496Fq7
ynvuXWIzdCJSYBe9CFjICgOeHLrz+9d66GiHfjkgU/RygUhLbgA1ogEsx+/4LshV
t3Tt02ECQQCmV771jice594L8PQmfSgHEZpzk8F2LkGB8BznVzcRpr/EtI6Bfux5
+HWAGW7CEwvv5r1oPzbYd9lggkanNXYdAkBvBd+NTHfoG1D89T/jkWrCX9IacRLX
AJpNq37kIaCRYnorHtv+YJ1AWWE7R89IK4jchBfxt6fZ35MYuyg8S3thAkAZSPlE
Bkm4DvLXydazCw9Mk8ZwjyM3PazDfaZHHCDI1BoOYovO72Yu3C+wOy103sRPwTlF
YWaK3Rzz6JmozR2ZAkBQsQhOXafSG1cGGx43mSzSAtBD1kfQAD2YVvR4B9NtOoWc
6Zyxf+Ek2P21ZIEWihTCM7XS9BYkJWHvcyun7Xeb";
    
    //map 键名
    public static final String PUBLIC_KEY = "RSAPublicKey";
    public static final String PRIVATE_KEY = "RSAPrivateKey";

    
    /**
     * 初始化密钥
     * @return
     */
    public static Map<String, String> initKey() {
        Map<String, String> map = new HashMap<String, String>();
        try {
            // 随机生成密钥对
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            
            // 按照指定字符串生成密钥对
            keyPairGen.initialize(1024, new SecureRandom());

            KeyPair keyPair = keyPairGen.generateKeyPair();
            
            // 公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            String pubkey = new String(Base64.encodeBase64(publicKey.getEncoded()));

            // 私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            String prikey = new String(Base64.encodeBase64(privateKey.getEncoded()));
            
            map.put(PUBLIC_KEY, pubkey);
            map.put(PRIVATE_KEY, prikey);
        } catch (Exception e) {
            logger.error("生成秘钥失败", e);
        }
        return map;
    }
    /**
     * 公钥加密
     * 
     * @param data
     * @param key
     * @return
     */
    public static String encryptByPublicKey(String data, String key) {
        try {
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(key));
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key publicKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);

            byte[] encryptedData = data.getBytes("utf-8");
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > 117) {
                    cache = cipher.doFinal(encryptedData, offSet, 117);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * 117;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            
            return new String(Base64.encodeBase64(decryptedData));
        } catch (Exception e) {
             logger.error("公钥加密异常!", e);
        }
        return data;
    }
    
    /**
     * 私钥解密
     * 
     * @param data
     * @param key
     * @return
     */
    public static String decryptByPrivateKey(String data, String key) {
        try {
            // 对密钥解密
            byte[] keyBytes = Base64.decodeBase64(key);

            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            byte[] encryptedData = Base64.decodeBase64(data);

            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > 128) {
                    cache = cipher.doFinal(encryptedData, offSet, 128);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * 128;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();

            return new String(decryptedData, "utf-8");

        } catch (Exception e) {
            logger.error("私钥解密异常", e);
        }
        return data;
    }
}