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;
     }
 }