使用RSA对WebService传递的信息加密解密的基本思想是：服务器端提供一个WebService方法String getServerPublicKey()，客户端可以以此得到服务器端的公钥，然后使用服务器端的公钥对要传出去的数据进行RSA加密，并附带以自己的公钥；服务器端得到客户端的请求后，先用自己的私钥解密客户端送来的数据，得到处理结果后用客户端提供的公钥加密，然后传回；客户端得到服务器端的返回数据后，用自己的私钥进行解密，最终得到了服务器端的真实数据。服务器端和客户端各自保存自己的RSA私钥用于解密，提供给对方RSA公钥进行加密，这样中间传递的信息就安全了。

  1. package com.szjz.web.czwwxgz.utils;
  2.  
  3. import org.apache.commons.codec.binary.Base64;
  4.  
  5. import java.io.*;
  6.  
  7. /** */
  8.  
  9. /**
  10.  * <p>
  11.  * BASE64编码解码工具包
  12.  * </p>
  13.  * <p>
  14.  * 依赖javabase64-1.3.1.jar
  15.  * </p>
  16.  *
  17.  * @author IceWee
  18.  * @version 1.0
  19.  * @date 2012-5-19
  20.  */
  21. public class Base64Utils {
  22.  
  23.     /** */
  24.     /**
  25.      * 文件读取缓冲区大小
  26.      */
  27.     private static final int CACHE_SIZE = 1024;
  28.  
  29.     /** */
  30.     /**
  31.      * <p>
  32.      * BASE64字符串解码为二进制数据
  33.      * </p>
  34.      *
  35.      * @param base64
  36.      * @return
  37.      * @throws Exception
  38.      */
  39.     public static byte[] decode(String base64) throws Exception {
  40.         return Base64.decodeBase64(base64.getBytes());
  41.     }
  42.  
  43.     /** */
  44.     /**
  45.      * <p>
  46.      * 二进制数据编码为BASE64字符串
  47.      * </p>
  48.      *
  49.      * @param bytes
  50.      * @return
  51.      * @throws Exception
  52.      */
  53.     public static String encode(byte[] bytes) throws Exception {
  54.         return new String(Base64.encodeBase64(bytes));
  55.     }
  56.  
  57.     /** */
  58.     /**
  59.      * <p>
  60.      * 将文件编码为BASE64字符串
  61.      * </p>
  62.      * <p>
  63.      * 大文件慎用，可能会导致内存溢出
  64.      * </p>
  65.      *
  66.      * @param filePath 文件绝对路径
  67.      * @return
  68.      * @throws Exception
  69.      */
  70.     public static String encodeFile(String filePath) throws Exception {
  71.         byte[] bytes = fileToByte(filePath);
  72.         return encode(bytes);
  73.     }
  74.  
  75.     /** */
  76.     /**
  77.      * <p>
  78.      * BASE64字符串转回文件
  79.      * </p>
  80.      *
  81.      * @param filePath 文件绝对路径
  82.      * @param base64   编码字符串
  83.      * @throws Exception
  84.      */
  85.     public static void decodeToFile(String filePath, String base64) throws Exception {
  86.         byte[] bytes = decode(base64);
  87.         byteArrayToFile(bytes, filePath);
  88.     }
  89.  
  90.     /** */
  91.     /**
  92.      * <p>
  93.      * 文件转换为二进制数组
  94.      * </p>
  95.      *
  96.      * @param filePath 文件路径
  97.      * @return
  98.      * @throws Exception
  99.      */
  100.     public static byte[] fileToByte(String filePath) throws Exception {
  101.         byte[] data = new byte[0];
  102.         File file = new File(filePath);
  103.         if (file.exists()) {
  104.             FileInputStream in = new FileInputStream(file);
  105.             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
  106.             byte[] cache = new byte[CACHE_SIZE];
  107.             int nRead = 0;
  108.             while ((nRead = in.read(cache)) != -1) {
  109.                 out.write(cache, 0, nRead);
  110.                 out.flush();
  111.             }
  112.             out.close();
  113.             in.close();
  114.             data = out.toByteArray();
  115.         }
  116.         return data;
  117.     }
  118.  
  119.     /** */
  120.     /**
  121.      * <p>
  122.      * 二进制数据写文件
  123.      * </p>
  124.      *
  125.      * @param bytes    二进制数据
  126.      * @param filePath 文件生成目录
  127.      */
  128.     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
  129.         InputStream in = new ByteArrayInputStream(bytes);
  130.         File destFile = new File(filePath);
  131.         if (!destFile.getParentFile().exists()) {
  132.             destFile.getParentFile().mkdirs();
  133.         }
  134.         destFile.createNewFile();
  135.         OutputStream out = new FileOutputStream(destFile);
  136.         byte[] cache = new byte[CACHE_SIZE];
  137.         int nRead = 0;
  138.         while ((nRead = in.read(cache)) != -1) {
  139.             out.write(cache, 0, nRead);
  140.             out.flush();
  141.         }
  142.         out.close();
  143.         in.close();
  144.     }
  145.  
  146. }
  1. package com.szjz.web.czwwxgz.utils;
  2.  
  3. import javax.crypto.Cipher;
  4. import java.io.ByteArrayOutputStream;
  5. import java.security.*;
  6. import java.security.interfaces.RSAPrivateKey;
  7. import java.security.interfaces.RSAPublicKey;
  8. import java.security.spec.PKCS8EncodedKeySpec;
  9. import java.security.spec.X509EncodedKeySpec;
  10. import java.util.HashMap;
  11. import java.util.Map;
  12.  
  13. /** */
  14.  
  15. /**
  16.  * <p>
  17.  * RSA公钥/私钥/签名工具包
  18.  * </p>
  19.  * <p>
  20.  * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
  21.  * </p>
  22.  * <p>
  23.  * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
  24.  * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
  25.  * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
  26.  * </p>
  27.  *
  28.  * @author IceWee
  29.  * @version 1.0
  30.  * @date 2012-4-26
  31.  */
  32. public class RSAUtils {
  33.  
  34.     /** */
  35.     /**
  36.      * 加密算法RSA
  37.      */
  38.     public static final String KEY_ALGORITHM = "RSA";
  39.  
  40.     /** */
  41.     /**
  42.      * 签名算法
  43.      */
  44.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  45.  
  46.     /** */
  47.     /**
  48.      * 获取公钥的key
  49.      */
  50.     private static final String PUBLIC_KEY = "RSAPublicKey";
  51.  
  52.     /** */
  53.     /**
  54.      * 获取私钥的key
  55.      */
  56.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  57.  
  58.     /** */
  59.     /**
  60.      * RSA最大加密明文大小
  61.      */
  62.     private static final int MAX_ENCRYPT_BLOCK = 117;
  63.  
  64.     /** */
  65.     /**
  66.      * RSA最大解密密文大小
  67.      */
  68.     private static final int MAX_DECRYPT_BLOCK = 128;
  69.  
  70.     /** */
  71.     /**
  72.      * <p>
  73.      * 生成密钥对(公钥和私钥)
  74.      * </p>
  75.      *
  76.      * @return
  77.      * @throws Exception
  78.      */
  79.     public static Map<String, Object> genKeyPair() throws Exception {
  80.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  81.         keyPairGen.initialize(1024);
  82.         KeyPair keyPair = keyPairGen.generateKeyPair();
  83.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  84.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  85.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
  86.         keyMap.put(PUBLIC_KEY, publicKey);
  87.         keyMap.put(PRIVATE_KEY, privateKey);
  88.         return keyMap;
  89.     }
  90.  
  91.     /** */
  92.     /**
  93.      * <p>
  94.      * 用私钥对信息生成数字签名
  95.      * </p>
  96.      *
  97.      * @param data       已加密数据
  98.      * @param privateKey 私钥(BASE64编码)
  99.      * @return
  100.      * @throws Exception
  101.      */
  102.     public static String sign(byte[] data, String privateKey) throws Exception {
  103.         byte[] keyBytes = Base64Utils.decode(privateKey);
  104.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  105.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  106.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  107.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  108.         signature.initSign(privateK);
  109.         signature.update(data);
  110.         return Base64Utils.encode(signature.sign());
  111.     }
  112.  
  113.     /** */
  114.     /**
  115.      * <p>
  116.      * 校验数字签名
  117.      * </p>
  118.      *
  119.      * @param data      已加密数据
  120.      * @param publicKey 公钥(BASE64编码)
  121.      * @param sign      数字签名
  122.      * @return
  123.      * @throws Exception
  124.      */
  125.     public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
  126.         byte[] keyBytes = Base64Utils.decode(publicKey);
  127.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  128.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  129.         PublicKey publicK = keyFactory.generatePublic(keySpec);
  130.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  131.         signature.initVerify(publicK);
  132.         signature.update(data);
  133.         return signature.verify(Base64Utils.decode(sign));
  134.     }
  135.  
  136.     /** */
  137.     /**
  138.      * <P>
  139.      * 私钥解密
  140.      * </p>
  141.      *
  142.      * @param encryptedData 已加密数据
  143.      * @param privateKey    私钥(BASE64编码)
  144.      * @return
  145.      * @throws Exception
  146.      */
  147.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
  148.         byte[] keyBytes = Base64Utils.decode(privateKey);
  149.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  150.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  151.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  152.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  153.         cipher.init(Cipher.DECRYPT_MODE, privateK);
  154.         int inputLen = encryptedData.length;
  155.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  156.         int offSet = 0;
  157.         byte[] cache;
  158.         int i = 0;
  159.         // 对数据分段解密
  160.         while (inputLen - offSet > 0) {
  161.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  162.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  163.             } else {
  164.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  165.             }
  166.             out.write(cache, 0, cache.length);
  167.             i++;
  168.             offSet = i * MAX_DECRYPT_BLOCK;
  169.         }
  170.         byte[] decryptedData = out.toByteArray();
  171.         out.close();
  172.         return decryptedData;
  173.     }
  174.  
  175.     /** */
  176.     /**
  177.      * <p>
  178.      * 公钥解密
  179.      * </p>
  180.      *
  181.      * @param encryptedData 已加密数据
  182.      * @param publicKey     公钥(BASE64编码)
  183.      * @return
  184.      * @throws Exception
  185.      */
  186.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
  187.         byte[] keyBytes = Base64Utils.decode(publicKey);
  188.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  189.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  190.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  191.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  192.         cipher.init(Cipher.DECRYPT_MODE, publicK);
  193.         int inputLen = encryptedData.length;
  194.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  195.         int offSet = 0;
  196.         byte[] cache;
  197.         int i = 0;
  198.         // 对数据分段解密
  199.         while (inputLen - offSet > 0) {
  200.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  201.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  202.             } else {
  203.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  204.             }
  205.             out.write(cache, 0, cache.length);
  206.             i++;
  207.             offSet = i * MAX_DECRYPT_BLOCK;
  208.         }
  209.         byte[] decryptedData = out.toByteArray();
  210.         out.close();
  211.         return decryptedData;
  212.     }
  213.  
  214.     /** */
  215.     /**
  216.      * <p>
  217.      * 公钥加密
  218.      * </p>
  219.      *
  220.      * @param data      源数据
  221.      * @param publicKey 公钥(BASE64编码)
  222.      * @return
  223.      * @throws Exception
  224.      */
  225.     public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
  226.         byte[] keyBytes = Base64Utils.decode(publicKey);
  227.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  228.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  229.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  230.         // 对数据加密
  231.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  232.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  233.         int inputLen = data.length;
  234.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  235.         int offSet = 0;
  236.         byte[] cache;
  237.         int i = 0;
  238.         // 对数据分段加密
  239.         while (inputLen - offSet > 0) {
  240.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  241.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  242.             } else {
  243.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  244.             }
  245.             out.write(cache, 0, cache.length);
  246.             i++;
  247.             offSet = i * MAX_ENCRYPT_BLOCK;
  248.         }
  249.         byte[] encryptedData = out.toByteArray();
  250.         out.close();
  251.         return encryptedData;
  252.     }
  253.  
  254.     /** */
  255.     /**
  256.      * <p>
  257.      * 私钥加密
  258.      * </p>
  259.      *
  260.      * @param data       源数据
  261.      * @param privateKey 私钥(BASE64编码)
  262.      * @return
  263.      * @throws Exception
  264.      */
  265.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
  266.         byte[] keyBytes = Base64Utils.decode(privateKey);
  267.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  268.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  269.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  270.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  271.         cipher.init(Cipher.ENCRYPT_MODE, privateK);
  272.         int inputLen = data.length;
  273.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  274.         int offSet = 0;
  275.         byte[] cache;
  276.         int i = 0;
  277.         // 对数据分段加密
  278.         while (inputLen - offSet > 0) {
  279.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  280.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  281.             } else {
  282.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  283.             }
  284.             out.write(cache, 0, cache.length);
  285.             i++;
  286.             offSet = i * MAX_ENCRYPT_BLOCK;
  287.         }
  288.         byte[] encryptedData = out.toByteArray();
  289.         out.close();
  290.         return encryptedData;
  291.     }
  292.  
  293.     /** */
  294.     /**
  295.      * <p>
  296.      * 获取私钥
  297.      * </p>
  298.      *
  299.      * @param keyMap 密钥对
  300.      * @return
  301.      * @throws Exception
  302.      */
  303.     public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
  304.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  305.         return Base64Utils.encode(key.getEncoded());
  306.     }
  307.  
  308.     /** */
  309.     /**
  310.      * <p>
  311.      * 获取公钥
  312.      * </p>
  313.      *
  314.      * @param keyMap 密钥对
  315.      * @return
  316.      * @throws Exception
  317.      */
  318.     public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
  319.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  320.         return Base64Utils.encode(key.getEncoded());
  321.     }
  322.  
  323.     /**
  324.      * java端公钥加密
  325.      */
  326.     public static String encryptedDataOnJava(String data, String PUBLICKEY) {
  327.         try {
  328.             data = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
  329.         } catch (Exception e) {
  330.             // TODO Auto-generated catch block
  331.             e.printStackTrace();
  332.         }
  333.         return data;
  334.     }
  335.  
  336.     /**
  337.      * java端私钥解密
  338.      */
  339.     public static String decryptDataOnJava(String data, String PRIVATEKEY) {
  340.         String temp = "";
  341.         try {
  342.             byte[] rs = Base64Utils.decode(data);
  343.             temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY), "UTF-8"); //以utf-8的方式生成字符串
  344.  
  345.         } catch (Exception e) {
  346.             e.printStackTrace();
  347.         }
  348.         return temp;
  349.     }
  350.  
  351. }
  1. package com.szjz.web.czwwxgz.utils;
  2.  
  3. import java.util.Map;
  4.  
  5. public class RSATester {
  6.  
  7.     static String publicKey;
  8.     static String privateKey;
  9.  
  10.     static {
  11.         try {
  12.             Map<String, Object> keyMap = RSAUtils.genKeyPair();
  13.             publicKey = RSAUtils.getPublicKey(keyMap);
  14.             privateKey = RSAUtils.getPrivateKey(keyMap);
  15.             System.err.println("公钥: \n\r" + publicKey);
  16.             System.err.println("私钥： \n\r" + privateKey);
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21.  
  22.     public static void main(String[] args) throws Exception {
  23.         testJavaRsa();
  24.     }
  25.  
  26.     public void tests() throws Exception {
  27.         String data = "hNYdT0/8wxljGvLQVPYUDeoWS217rmB5msKOljb6OBsOhdL1Domxt6Sy3BqdGqS3StGJuZuQ9wEFzGdyoTQ7IRiC0gRrkLuxvCUq8FANt1JpJCBqvzLdQD/ygCjkJMWWkMU4EFUW3xYkAsidqM8Zynhpk+mdja3789Ng4s68xJI=";
  28.  
  29.         String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==";
  30.         byte[] rs = Base64Utils.decode(data);
  31.  
  32.         String r1 = new String(RSAUtils.decryptByPrivateKey(rs, privateKey));
  33.  
  34.         System.out.println("\r\n\r\n" + r1 + "okb");
  35.  
  36.     }
  37.  
  38.     static void testSign() throws Exception {
  39.         System.err.println("私钥加密——公钥解密");
  40.         String source = "32232";
  41.         System.out.println("原文字：\r\n" + source);
  42.         byte[] data = source.getBytes();
  43.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
  44.         System.out.println("加密后：\r\n" + new String(encodedData));
  45.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
  46.         String target = new String(decodedData);
  47.         System.out.println("解密后: \r\n" + target);
  48.         System.err.println("私钥签名——公钥验证签名");
  49.         String sign = RSAUtils.sign(encodedData, privateKey);
  50.         System.err.println("签名:\r" + sign);
  51.         boolean status = RSAUtils.verify(encodedData, publicKey, sign);
  52.         System.err.println("验证结果:\r" + status);
  53.     }
  54.  
  55.     static void test() throws Exception {
  56.         System.err.println("公钥加密——私钥解密");
  57.         String source = "这是一行没有任何意义的文字，你看完了等于没看，不是吗？";
  58.         System.out.println("\r加密前文字：\r\n" + source);
  59.         byte[] data = source.getBytes();
  60.         byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
  61.         System.out.println("加密后文字：\r\n" + new String(encodedData));
  62.         System.out.println("----------------:base64处理：" + Base64Utils.encode(encodedData));
  63.         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
  64.         String target = new String(decodedData);
  65.         System.out.println("解密后文字: \r\n" + target);
  66.     }
  67.  
  68.     /*
  69.      * 测试自己封装java端加密和解密的方法
  70.      */
  71.  
  72.     static void testJavaRsa() {
  73.         String PUBLICKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCcd+0zTY9Gn94iqkQJTlxYnEnCeFsLkk0a7hoAvi2B74VzDVV3xH0ZO9RkXvo1SgCB+uzbEWdrgQkzTqyjfTtgOguu3OnkVxIMJF34ibchTY0LWHGxq1m2gLGuVVqrlu1LtdV0X7xo/5zc8Mr+46veWb86kSpqe6rOAm69WWo5GwIDAQAB";
  74.         String PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJx37TNNj0af3iKqRAlOXFicScJ4WwuSTRruGgC+LYHvhXMNVXfEfRk71GRe+jVKAIH67NsRZ2uBCTNOrKN9O2A6C67c6eRXEgwkXfiJtyFNjQtYcbGrWbaAsa5VWquW7Uu11XRfvGj/nNzwyv7jq95ZvzqRKmp7qs4Cbr1ZajkbAgMBAAECgYAHp349EkA+DjgJrhah9elilFKvZr/dcwy+koNHIgaL4rG+jRpvP3d3MowTVOocjUA1G5dWqCVNBwTyM5kSbl/nIxSCYwdUoDid4r0JbqkXkTTsIq3euHG8eiWr9rr3SDmwDojWoJEc4liVlfme8dQuMfgxe1QKq7wTrJwCKwbeMQJBAPwpknRPRK8W9hefbbtEu8mlbzUy+ER8Puq6dvS+lnWzJ8n2chJcHRYQFwWpjl4+SZuKeEcDmYmuQ7xuqEIayO0CQQCe2YeaxcU4uuDC45RAwCcMaNw1nDJuA+Gi47lXbroBXoeOiNZunViSZVUgDgrV/Ku6V54TaZIzZ21QFjf7mXEnAkEA7dZwMpAJonOvzfwrzbQ4wyrsx2q5zC68UT1qsdGJrJ48azutwC9tp7+pV0fj5nQtjS1/4Ms+aCQb84ET5rXIyQJAM0m45tgEHZT5DPO94kooUXFp6EVOYwcNyzILnZc6p0aGLhcwZPaYqmvdWEQwa3bxW3D+sPXdJou2V61U1f9s8QJALccvYwwWlCTq1iTmegYk9fOoc+isZKH+Z0YW70kFi94AYEO+utYwmXBEAqQ5VC/bywa1O71xdL4/RGCOSxBf2A==";
  75.         String data = "123";
  76.         data = RSAUtils.encryptedDataOnJava(data, PUBLICKEY);
  77.         System.out.println("加密数据：" + data);
  78.  
  79.         System.out.println("解密数据：" + RSAUtils.decryptDataOnJava(data, PRIVATEKEY));
  80.     }
  81.  
  82.     static void testFrontEncrptAndAfterDecrypt() {
  83.         String PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==";
  84.         String data = "FBGU7sQfpSfCgB2hqFuIqkivEUHVRHD8JFdyxYeWqQHsTj9UEuVmvi28n1fOHRwW+3aZD3ttdzfUHWiXD2NErcX/CYs5BtSXT7RcJfWWcXvegq5BBDEAJCADWCRdYnblN+SLUC+ctDXcLw4xmjwAajowSzhCfY/lU3TdnJjO488=";
  85.         System.out.println("解密数据：" + RSAUtils.decryptDataOnJava(data, PRIVATEKEY));
  86.     }
  87.  
  88. }

RSA非对称加密（java实例代码）的更多相关文章

  1. RSA非对称加密Java实现

    原文 加密基础方法类 import java.security.MessageDigest; import sun.misc.BASE64Decoder; import sun.misc.BASE64 ...

  2. JSON 接口如何实现 RSA 非对称加密与签名

    代码地址如下:http://www.demodashi.com/demo/14000.html 一.概述 1. 数字签名的作用:保证数据完整性,机密性和发送方角色的不可抵赖性,加密与签字结合时,两套公 ...

  3. 前后端API交互数据加密——AES与RSA混合加密完整实例

    前言 前段时间看到一篇文章讲如何保证API调用时数据的安全性(传送门:https://blog.csdn.net/ityouknow/article/details/80603617),文中讲到利用R ...

  4. 前后端数据加密传输 RSA非对称加密

    任务需求:要求登陆时将密码加密之后再进行传输到后端. 经过半天查询摸索折腾,于是有了如下成果: 加密方式:RSA非对称加密.实现方式:公钥加密,私钥解密.研究进度:javascript与java端皆已 ...

  5. CryptoAPI与openssl RSA非对称加密解密(PKCS1 PADDING)交互

    (以下代码中都只做测试用,有些地方没有释放内存...这个自己解决下) 1.RSA非对称的,首先提供一个供测试用的证书和私钥的数据 1)pem格式的证书和私钥(公私钥是对应的)的base64编码 voi ...

  6. 前端js，后台python实现RSA非对称加密

    先熟悉使用 在后台使用RSA实现秘钥生产,加密,解密; # -*- encoding:utf-8 -*- import base64 from Crypto import Random from Cr ...

  7. RSA 非对称加密，私钥转码为pkcs8 错误总结

    RSA 非对称加密,私钥转码为pkcs8 错误总结 最近在和某上市公司对接金融方面的业务时,关于RSA对接过程中遇到了一个坑,特来分享下解决方案. 该上市公司简称为A公司,我们简称为B公司.A-B两家 ...

  8. javascript版前端页面RSA非对称加密解密

    最近由于项目需要做一个url传参,并在页面显示参数内容的需求,这样就会遇到一个url地址可能会被假冒, 并传递非法内容显示在页面的尴尬情况 比如xxx.shtml?server=xxx是坏人& ...

  9. Atitit RSA非对称加密原理与解决方案

    Atitit RSA非对称加密原理与解决方案 1.1. 一.一点历史 1 1.2. 八.加密和解密 2 1.3. 二.基于RSA的消息传递机制  3 1.4. 基于rsa的授权验证机器码 4 1.5. ...

  10. php RSA非对称加密 的实现

    基本概念 加密的意义 加密的意义在于数据的传输过程中,即使被第三方获取到传输的数据,第三方也不能获取到数据的具体含义. 加密方式分为对称加密和非对称加密 什么是对称加密? 对称加密只使用一个秘钥,加密 ...

随机推荐

  1. Markdown画图(mermaid)学习

    简介 目前博客园支持mermaid的graph,subgraph,sequenceDiagram,gantt,classDiagram mermaid(美人鱼), 是一个类似markdown,用文本语 ...

  2. Debug LinkedList

    Debug LinkedList源码 前置知识 LinkedList基于链表,LinkedList的Node节点定义 成员变量 //链表中元素的数量 transient int size = 0; / ...

  3. Salt组件之管理对象Target

    管理对象 Target 在Master上我们可以采用不同Target去管理不同的Minion.这些Target都是通过去管理和匹配Minion的ID来做的一些集合. 1.正则匹配,参数-E,你可以写任 ...

  4. Metal 线宽如何选择

    https://www.cnblogs.com/yeungchie/ Metal 线宽如何选择 假如Metal是为了传输电流,则主要需要从解决和减小它的寄生电阻.寄生电容方面多做考虑.寄生电感一般忽略 ...

  5. C/C++编程笔记：C语言写推箱子小游戏，大一学习C语言练手项目

    C语言,作为大多数人的第一门编程语言,重要性不言而喻,很多编程习惯,逻辑方式在此时就已经形成了.这个是我在大一学习 C语言 后写的推箱子小游戏,自己的逻辑能力得到了提升,在这里同大家分享这个推箱子小游 ...

  6. CF804D Expected diameter of a tree 树的直径 根号分治

    LINK:Expected diameter of a tree 1e5 带根号log 竟然能跑过! 容易想到每次连接两个联通快 快速求出直径 其实是 \(max(D1,D2,f_x+f_y+1)\) ...

  7. 在新的线程中使用session 出现的问题

    Exception in thread "Thread-15" java.lang.IllegalStateException: No thread-bound request f ...

  8. 使用Flask开发简单接口(2)--POST请求接口

    今天我们继续学习如何使用Flask开发POST接口:用户注册接口和用户登录接口. request接收参数 当我们在页面发出一个POST请求,请求传到服务器时,需要如何拿到当前请求的数据呢?在Flask ...

  9. Java 添加、删除、格式化Word中的图片

    本文介绍使用Spire.Cloud.SDK for Java提供的ImagesApi接口来操作Word中的图片.具体可通过addImage()方法添加图片.deleteImage()方法删除图片.up ...

  10. 【USACO02FEB】Rebuilding Roads 重建道路 题解（树形DP）

    题目链接 题目大意:问使含有$p$个节点的子树分离至少需要去掉几条边. ------------------ 设$f[i][j]$表示以$i$为根的子树保留$j$个节点所去掉的最少边数. 初始化$f[ ...