package data;    import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;import com.wustrive.aesrsa.util.Base64;  /** *//**  * 
  * BASE64编码解码工具包  * 
  * 
  * 依赖javabase64-1.3.1.jar  * 
  *   * @author jun * @date 2012-5-19  * @version 1.0  */  public class Base64Utils {        /** *//**      * 文件读取缓冲区大小      */      private static final int CACHE_SIZE = 1024;            /** *//**      * 
      * BASE64字符串解码为二进制数据      * 
      *       * @param base64      * @return      * @throws Exception      */      public static byte[] decode(String base64) throws Exception {          return Base64.decode(base64.getBytes());      }            /** *//**      * 
      * 二进制数据编码为BASE64字符串      * 
      *       * @param bytes      * @return      * @throws Exception      */      public static String encode(byte[] bytes) throws Exception {          return new String(Base64.encode(bytes));      }            /** *//**      * 
      * 将文件编码为BASE64字符串      * 
      * 
      * 大文件慎用，可能会导致内存溢出      * 
      *       * @param filePath 文件绝对路径      * @return      * @throws Exception      */      public static String encodeFile(String filePath) throws Exception {          byte[] bytes = fileToByte(filePath);          return encode(bytes);      }            /** *//**      * 
      * BASE64字符串转回文件      * 
      *       * @param filePath 文件绝对路径      * @param base64 编码字符串      * @throws Exception      */      public static void decodeToFile(String filePath, String base64) throws Exception {          byte[] bytes = decode(base64);          byteArrayToFile(bytes, filePath);      }            /** *//**      * 
      * 文件转换为二进制数组      * 
      *       * @param filePath 文件路径      * @return      * @throws Exception      */      public static byte[] fileToByte(String filePath) throws Exception {          byte[] data = new byte[0];          File file = new File(filePath);          if (file.exists()) {              FileInputStream in = new FileInputStream(file);              ByteArrayOutputStream out = new ByteArrayOutputStream(2048);              byte[] cache = new byte[CACHE_SIZE];              int nRead = 0;              while ((nRead = in.read(cache)) != -1) {                  out.write(cache, 0, nRead);                  out.flush();              }              out.close();              in.close();              data = out.toByteArray();           }          return data;      }            /** *//**      * 
      * 二进制数据写文件      * 
      *       * @param bytes 二进制数据      * @param filePath 文件生成目录      */      public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {          InputStream in = new ByteArrayInputStream(bytes);             File destFile = new File(filePath);          if (!destFile.getParentFile().exists()) {              destFile.getParentFile().mkdirs();          }          destFile.createNewFile();          OutputStream out = new FileOutputStream(destFile);          byte[] cache = new byte[CACHE_SIZE];          int nRead = 0;          while ((nRead = in.read(cache)) != -1) {                 out.write(cache, 0, nRead);              out.flush();          }          out.close();          in.close();      }              }

package data;import java.util.Map;import com.alibaba.fastjson.JSONObject;public class RSATest {	private static  String DEFAULT_PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDosvH1gCpQTTZLXGMcSeeqDjWuDVY0+Aab1VbtGJqWdkPd32D4hEUwFjVJ+FJbq7UpvFFDQ3k2y2n/1rzxWapFk/e+BNNCSKP9e6+Of1SLs83So27dgiAeAKmdQoxwfXrgvP1/QRMJJ0i6m3CRRyTlXO+cMGbYqRv1iTT9uaRolQIDAQAB";	private static  String DEFAULT_PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAOiy8fWAKlBNNktcYxxJ56oONa4NVjT4BpvVVu0YmpZ2Q93fYPiERTAWNUn4UlurtSm8UUNDeTbLaf/WvPFZqkWT974E00JIo/17r45/VIuzzdKjbt2CIB4AqZ1CjHB9euC8/X9BEwknSLqbcJFHJOVc75wwZtipG/WJNP25pGiVAgMBAAECgYEAv4PXY8hyCtkhYHDPGU8yHWHIiFFtq/ad6c9x1X00bbU0Mf1Q3/hswSDmBtUbY1s0pP7amtODhbdwrCFeK/0yBrOegb2fQeJs/QL6/y4/DPzRB21k9N8cQjgmv5tQb72fwdY8nDROXnzKQceMo6b/xkWaIhvhdUq6nCqPvoIGRIECQQD+lOKTQk769G9BQd7HW+2H2NioPbxri+V27daC1M5uBfBj8Wt3NDJ5IyMvOHz5yTlm8FsE2Zz1/aFdLJ/Rv4IRAkEA6f7ZOMcuxlRsAiN708+r3q3sxAyBood+qAJ1MKhOrdR94RcAPUkcjFTZ8j1v0eclj6+w2RChcpb5Ath93ia6RQJBAP3b6x+axHUcn4A8NfEn6vFGu6zwet3nT3bLbddia0JtK6wNhfMFGruO3TvuITlXfaT3UlvAv/LP6kOmBuw6AnECQQDR3r29awjM4ZMuJ908EJs6Ugx1mjH7MEOtNOcfCRXoWxm79QFF9nkgdEo2NlxAi2zo/s9DIONs/3O/1aSux1VxAkBkkOdc0f2ogWZHqtCYfVfYjwbMvlW/6lnbq0B76V1SVqogoSubwnF7EUBdmqpzWmzqM4xURBh9QqDnUUfBzPMW";		public static void main(String[] args) throws Exception {		mytest();		//test();		// testSign();//		encodeRequest(null);	}		static void mytest()throws Exception{				//生产公钥私钥		Map
     
       keyMap = RSAUtils.genKeyPair();				DEFAULT_PRIVATE_KEY = RSAUtils.getPrivateKey(keyMap);				DEFAULT_PUBLIC_KEY = RSAUtils.getPublicKey(keyMap);				System.out.println("DEFAULT_PRIVATE_KEY:"+DEFAULT_PRIVATE_KEY);				System.out.println("DEFAULT_PUBLIC_KEY:"+DEFAULT_PUBLIC_KEY);										System.err.println("公钥加密——私钥解密");		String source = "这是一行没有任何意义的文字，你看完了等于没看士大夫反反复复反反复复反反复复反反复复多发时段发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生，不是吗？这是一行没有任何意义的文字，asdfsdafsdafsfasdfdfsa你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？";		System.out.println("\r加密前文字：\r\n" + source);		byte[] data = source.getBytes();		byte[] encodedData = RSAUtils.encryptByPublicKey(data, DEFAULT_PUBLIC_KEY);		System.out.println("加密后文字：\r\n" + new String(encodedData));		byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData,				DEFAULT_PRIVATE_KEY);		String target = new String(decodedData);		System.out.println("解密后文字: \r\n" + target);	}	static void test() throws Exception {		System.err.println("公钥加密——私钥解密");		String source = "这是一行没有任何意义的文字，你看完了等于没看士大夫反反复复反反复复反反复复反反复复多发时段发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生的发生，不是吗？这是一行没有任何意义的文字，asdfsdafsdafsfasdfdfsa你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？这是一行没有任何意义的文字，你看完了等于没看，不是吗？";		System.out.println("\r加密前文字：\r\n" + source);		byte[] data = source.getBytes();		byte[] encodedData = RSAUtils.encryptByPublicKey(data, DEFAULT_PUBLIC_KEY);		System.out.println("加密后文字：\r\n" + new String(encodedData));		byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData,				DEFAULT_PRIVATE_KEY);		String target = new String(decodedData);		System.out.println("解密后文字: \r\n" + target);	}	static void encodeRequest(JSONObject json) throws Exception{		JSONObject jsonObject = new JSONObject();		for(int i=0;i<1000;i++){			jsonObject.put(i+"","value"+i);		}		byte[] data = jsonObject.toString().getBytes();		byte[] encodedData = RSAUtils.encryptByPublicKey(data, DEFAULT_PUBLIC_KEY);		System.out.println("加密后文字：\r\n" + new String(encodedData));		byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData,				DEFAULT_PRIVATE_KEY);		String target = new String(decodedData);		System.out.println("解密后文字: \r\n" + target);	}									}
     

package data;    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;    /** *//**  * 
  * RSA公钥/私钥/签名工具包  * 
  * 
  * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）  * 
  * 
  * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式
  * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，
  * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全  * 
  *   * @author IceWee  JUN * @date 2012-4-26  * @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;        /** *//**      * 
      * 生成密钥对(公钥和私钥)      * 
      *       * @return      * @throws Exception      */      public static Map
     
       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
      
        keyMap = new HashMap
       
        (2);          keyMap.put(PUBLIC_KEY, publicKey);          keyMap.put(PRIVATE_KEY, privateKey);          return keyMap;      }            /** *//**      * 
        
      * 用私钥对信息生成数字签名      * 
      *       * @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());      }        /** *//**      * 
        
      * 校验数字签名      * 
      *       * @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));      }        /** *//**      * 
        
      * 私钥解密      * 
      *       * @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 cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");                 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;      }        /** *//**      * 
        
      * 公钥解密      * 
      *       * @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 cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");         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;      }        /** *//**      * 
        
      * 公钥加密      * 
      *       * @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 cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");         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;      }        /** *//**      * 
        
      * 私钥加密      * 
      *       * @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 cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");         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;      }        /** *//**      * 
        
      * 获取私钥      * 
      *       * @param keyMap 密钥对      * @return      * @throws Exception      */      public static String getPrivateKey(Map
        
          keyMap)              throws Exception {          Key key = (Key) keyMap.get(PRIVATE_KEY);          return Base64Utils.encode(key.getEncoded());      }        /** *//**      * 
         
      * 获取公钥      * 
      *       * @param keyMap 密钥对      * @return      * @throws Exception      */      public static String getPublicKey(Map
         
           keyMap)              throws Exception {          Key key = (Key) keyMap.get(PUBLIC_KEY);          return Base64Utils.encode(key.getEncoded());      }    }