devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java RSA加密解密实现_base64utils.encode(rsautils.encryptbypublicke

作者：小蓝xlanll | 2024-03-07 01:56:05

赞

踩

base64utils.encode(rsautils.encryptbypublicke

该工具类中用到了BASE64，需要借助第三方类库：javabase64-1.3.1.jar 被我改成 了commons-codec-xxx.jar。当然了你也可以使用jdk1.8的Base64，听说效率更高。这里我就不改了。

注意：
RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。
RSA加密对明文的长度是有限制的，如果加密数据过大会抛出如下异常：

  1. Exception in thread "main" javax.crypto.IllegalBlockSizeException: Data must not be longer than 117 bytes
  2. 	at com.sun.crypto.provider.RSACipher.a(DashoA13*..)
  3. 	at com.sun.crypto.provider.RSACipher.engineDoFinal(DashoA13*..)
  4. 	at javax.crypto.Cipher.doFinal(DashoA13*..)
  5. 	
RSAUtils.java

 

  1.  
  2. import java.io.ByteArrayOutputStream;
  3. import java.security.Key;
  4. import java.security.KeyFactory;
  5. import java.security.KeyPair;
  6. import java.security.KeyPairGenerator;
  7. import java.security.PrivateKey;
  8. import java.security.PublicKey;
  9. import java.security.Signature;
  10. import java.security.interfaces.RSAPrivateKey;
  11. import java.security.interfaces.RSAPublicKey;
  12. import java.security.spec.PKCS8EncodedKeySpec;
  13. import java.security.spec.X509EncodedKeySpec;
  14. import java.util.HashMap;
  15. import java.util.Map;
  16.  
  17. import javax.crypto.Cipher;
  18.  
  19. /** *//**
  20.  * <p>
  21.  * RSA公钥/私钥/签名工具包
  22.  * </p>
  23.  * <p>
  24.  * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
  25.  * </p>
  26.  * <p>
  27.  * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
  28.  * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
  29.  * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
  30.  * </p>
  31.  * 
  32.  * @author IceWee
  33.  * @date 2012-4-26
  34.  * @version 1.0
  35.  */
  36. public class RSAUtils {
  37.  
  38.     /** *//**
  39.      * 加密算法RSA
  40.      */
  41.     public static final String KEY_ALGORITHM = "RSA";
  42.     
  43.     /** *//**
  44.      * 签名算法
  45.      */
  46.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
  47.  
  48.     /** *//**
  49.      * 获取公钥的key
  50.      */
  51.     private static final String PUBLIC_KEY = "RSAPublicKey";
  52.     
  53.     /** *//**
  54.      * 获取私钥的key
  55.      */
  56.     private static final String PRIVATE_KEY = "RSAPrivateKey";
  57.     
  58.     /** *//**
  59.      * RSA最大加密明文大小
  60.      */
  61.     private static final int MAX_ENCRYPT_BLOCK = 117;
  62.     
  63.     /** *//**
  64.      * RSA最大解密密文大小
  65.      */
  66.     private static final int MAX_DECRYPT_BLOCK = 128;
  67.  
  68.     /** *//**
  69.      * <p>
  70.      * 生成密钥对(公钥和私钥)
  71.      * </p>
  72.      * 
  73.      * @return
  74.      * @throws Exception
  75.      */
  76.     public static Map<String, Object> genKeyPair() throws Exception {
  77.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
  78.         keyPairGen.initialize(1024);
  79.         KeyPair keyPair = keyPairGen.generateKeyPair();
  80.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
  81.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
  82.         Map<String, Object> keyMap = new HashMap<String, Object>(2);
  83.         keyMap.put(PUBLIC_KEY, publicKey);
  84.         keyMap.put(PRIVATE_KEY, privateKey);
  85.         return keyMap;
  86.     }
  87.     
  88.     /** *//**
  89.      * <p>
  90.      * 用私钥对信息生成数字签名
  91.      * </p>
  92.      * 
  93.      * @param data 已加密数据
  94.      * @param privateKey 私钥(BASE64编码)
  95.      * 
  96.      * @return
  97.      * @throws Exception
  98.      */
  99.     public static String sign(byte[] data, String privateKey) throws Exception {
  100.         byte[] keyBytes = Base64Utils.decode(privateKey);
  101.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  102.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  103.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  104.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  105.         signature.initSign(privateK);
  106.         signature.update(data);
  107.         return Base64Utils.encode(signature.sign());
  108.     }
  109.  
  110.     /** *//**
  111.      * <p>
  112.      * 校验数字签名
  113.      * </p>
  114.      * 
  115.      * @param data 已加密数据
  116.      * @param publicKey 公钥(BASE64编码)
  117.      * @param sign 数字签名
  118.      * 
  119.      * @return
  120.      * @throws Exception
  121.      * 
  122.      */
  123.     public static boolean verify(byte[] data, String publicKey, String sign)
  124.             throws Exception {
  125.         byte[] keyBytes = Base64Utils.decode(publicKey);
  126.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
  127.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  128.         PublicKey publicK = keyFactory.generatePublic(keySpec);
  129.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
  130.         signature.initVerify(publicK);
  131.         signature.update(data);
  132.         return signature.verify(Base64Utils.decode(sign));
  133.     }
  134.  
  135.     /** *//**
  136.      * <P>
  137.      * 私钥解密
  138.      * </p>
  139.      * 
  140.      * @param encryptedData 已加密数据
  141.      * @param privateKey 私钥(BASE64编码)
  142.      * @return
  143.      * @throws Exception
  144.      */
  145.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
  146.             throws Exception {
  147.         byte[] keyBytes = Base64Utils.decode(privateKey);
  148.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  149.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  150.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  151.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  152.         cipher.init(Cipher.DECRYPT_MODE, privateK);
  153.         int inputLen = encryptedData.length;
  154.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  155.         int offSet = 0;
  156.         byte[] cache;
  157.         int i = 0;
  158.         // 对数据分段解密
  159.         while (inputLen - offSet > 0) {
  160.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  161.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  162.             } else {
  163.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  164.             }
  165.             out.write(cache, 0, cache.length);
  166.             i++;
  167.             offSet = i * MAX_DECRYPT_BLOCK;
  168.         }
  169.         byte[] decryptedData = out.toByteArray();
  170.         out.close();
  171.         return decryptedData;
  172.     }
  173.  
  174.     /** *//**
  175.      * <p>
  176.      * 公钥解密
  177.      * </p>
  178.      * 
  179.      * @param encryptedData 已加密数据
  180.      * @param publicKey 公钥(BASE64编码)
  181.      * @return
  182.      * @throws Exception
  183.      */
  184.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
  185.             throws Exception {
  186.         byte[] keyBytes = Base64Utils.decode(publicKey);
  187.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  188.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  189.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  190.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  191.         cipher.init(Cipher.DECRYPT_MODE, publicK);
  192.         int inputLen = encryptedData.length;
  193.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  194.         int offSet = 0;
  195.         byte[] cache;
  196.         int i = 0;
  197.         // 对数据分段解密
  198.         while (inputLen - offSet > 0) {
  199.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  200.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  201.             } else {
  202.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
  203.             }
  204.             out.write(cache, 0, cache.length);
  205.             i++;
  206.             offSet = i * MAX_DECRYPT_BLOCK;
  207.         }
  208.         byte[] decryptedData = out.toByteArray();
  209.         out.close();
  210.         return decryptedData;
  211.     }
  212.  
  213.     /** *//**
  214.      * <p>
  215.      * 公钥加密
  216.      * </p>
  217.      * 
  218.      * @param data 源数据
  219.      * @param publicKey 公钥(BASE64编码)
  220.      * @return
  221.      * @throws Exception
  222.      */
  223.     public static byte[] encryptByPublicKey(byte[] data, String publicKey)
  224.             throws Exception {
  225.         byte[] keyBytes = Base64Utils.decode(publicKey);
  226.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  227.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  228.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  229.         // 对数据加密
  230.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  231.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  232.         int inputLen = data.length;
  233.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  234.         int offSet = 0;
  235.         byte[] cache;
  236.         int i = 0;
  237.         // 对数据分段加密
  238.         while (inputLen - offSet > 0) {
  239.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  240.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  241.             } else {
  242.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  243.             }
  244.             out.write(cache, 0, cache.length);
  245.             i++;
  246.             offSet = i * MAX_ENCRYPT_BLOCK;
  247.         }
  248.         byte[] encryptedData = out.toByteArray();
  249.         out.close();
  250.         return encryptedData;
  251.     }
  252.  
  253.     /** *//**
  254.      * <p>
  255.      * 私钥加密
  256.      * </p>
  257.      * 
  258.      * @param data 源数据
  259.      * @param privateKey 私钥(BASE64编码)
  260.      * @return
  261.      * @throws Exception
  262.      */
  263.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
  264.             throws Exception {
  265.         byte[] keyBytes = Base64Utils.decode(privateKey);
  266.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  267.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  268.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  269.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
  270.         cipher.init(Cipher.ENCRYPT_MODE, privateK);
  271.         int inputLen = data.length;
  272.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  273.         int offSet = 0;
  274.         byte[] cache;
  275.         int i = 0;
  276.         // 对数据分段加密
  277.         while (inputLen - offSet > 0) {
  278.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  279.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  280.             } else {
  281.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  282.             }
  283.             out.write(cache, 0, cache.length);
  284.             i++;
  285.             offSet = i * MAX_ENCRYPT_BLOCK;
  286.         }
  287.         byte[] encryptedData = out.toByteArray();
  288.         out.close();
  289.         return encryptedData;
  290.     }
  291.  
  292.     /** *//**
  293.      * <p>
  294.      * 获取私钥
  295.      * </p>
  296.      * 
  297.      * @param keyMap 密钥对
  298.      * @return
  299.      * @throws Exception
  300.      */
  301.     public static String getPrivateKey(Map<String, Object> keyMap)
  302.             throws Exception {
  303.         Key key = (Key) keyMap.get(PRIVATE_KEY);
  304.         return Base64Utils.encode(key.getEncoded());
  305.     }
  306.  
  307.     /** *//**
  308.      * <p>
  309.      * 获取公钥
  310.      * </p>
  311.      * 
  312.      * @param keyMap 密钥对
  313.      * @return
  314.      * @throws Exception
  315.      */
  316.     public static String getPublicKey(Map<String, Object> keyMap)
  317.             throws Exception {
  318.         Key key = (Key) keyMap.get(PUBLIC_KEY);
  319.         return Base64Utils.encode(key.getEncoded());
  320.     }
  321.  
  322. }

 

Base64Utils.java
  1.  
  2. import java.io.ByteArrayInputStream;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.InputStream;
  8. import java.io.OutputStream;
  9.  
  10. import org.apache.commons.codec.binary.Base64;
  11.  
  12.  
  13. /** *//**
  14.  * <p>
  15.  * BASE64编码解码工具包
  16.  * </p>
  17.  * <p>
  18.  * 依赖javabase64-1.3.1.jar
  19.  * </p>
  20.  * 
  21.  * @author IceWee
  22.  * @date 2012-5-19
  23.  * @version 1.0
  24.  */
  25. public class Base64Utils {
  26. 	static Base64 bas64=null;
  27. 	static{
  28. 		bas64 = new Base64();
  29. 	}
  30.  
  31.     /** *//**
  32.      * 文件读取缓冲区大小
  33.      */
  34.     private static final int CACHE_SIZE = 1024;
  35.     
  36.     /** *//**
  37.      * <p>
  38.      * BASE64字符串解码为二进制数据
  39.      * </p>
  40.      * 
  41.      * @param base64
  42.      * @return
  43.      * @throws Exception
  44.      */
  45.     public static byte[] decode(String base64) throws Exception {
  46.         return bas64.decode(base64.getBytes());
  47.     }
  48.     
  49.     /** *//**
  50.      * <p>
  51.      * 二进制数据编码为BASE64字符串
  52.      * </p>
  53.      * 
  54.      * @param bytes
  55.      * @return
  56.      * @throws Exception
  57.      */
  58.     public  static String encode(byte[] bytes) throws Exception {
  59.         return new String(bas64.encode(bytes));
  60.     }
  61.     
  62.     /** *//**
  63.      * <p>
  64.      * 将文件编码为BASE64字符串
  65.      * </p>
  66.      * <p>
  67.      * 大文件慎用，可能会导致内存溢出
  68.      * </p>
  69.      * 
  70.      * @param filePath 文件绝对路径
  71.      * @return
  72.      * @throws Exception
  73.      */
  74.     public  String encodeFile(String filePath) throws Exception {
  75.         byte[] bytes = fileToByte(filePath);
  76.         return encode(bytes);
  77.     }
  78.     
  79.     /** *//**
  80.      * <p>
  81.      * BASE64字符串转回文件
  82.      * </p>
  83.      * 
  84.      * @param filePath 文件绝对路径
  85.      * @param base64 编码字符串
  86.      * @throws Exception
  87.      */
  88.     public  void decodeToFile(String filePath, String base64) throws Exception {
  89.         byte[] bytes = decode(base64);
  90.         byteArrayToFile(bytes, filePath);
  91.     }
  92.     
  93.     /** *//**
  94.      * <p>
  95.      * 文件转换为二进制数组
  96.      * </p>
  97.      * 
  98.      * @param filePath 文件路径
  99.      * @return
  100.      * @throws Exception
  101.      */
  102.     public static byte[] fileToByte(String filePath) throws Exception {
  103.         byte[] data = new byte[0];
  104.         File file = new File(filePath);
  105.         if (file.exists()) {
  106.             FileInputStream in = new FileInputStream(file);
  107.             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
  108.             byte[] cache = new byte[CACHE_SIZE];
  109.             int nRead = 0;
  110.             while ((nRead = in.read(cache)) != -1) {
  111.                 out.write(cache, 0, nRead);
  112.                 out.flush();
  113.             }
  114.             out.close();
  115.             in.close();
  116.             data = out.toByteArray();
  117.          }
  118.         return data;
  119.     }
  120.     
  121.     /** *//**
  122.      * <p>
  123.      * 二进制数据写文件
  124.      * </p>
  125.      * 
  126.      * @param bytes 二进制数据
  127.      * @param filePath 文件生成目录
  128.      */
  129.     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
  130.         InputStream in = new ByteArrayInputStream(bytes);   
  131.         File destFile = new File(filePath);
  132.         if (!destFile.getParentFile().exists()) {
  133.             destFile.getParentFile().mkdirs();
  134.         }
  135.         destFile.createNewFile();
  136.         OutputStream out = new FileOutputStream(destFile);
  137.         byte[] cache = new byte[CACHE_SIZE];
  138.         int nRead = 0;
  139.         while ((nRead = in.read(cache)) != -1) {   
  140.             out.write(cache, 0, nRead);
  141.             out.flush();
  142.         }
  143.         out.close();
  144.         in.close();
  145.     }
  146.     
  147.     
  148. }

测试类 

  1.  
  2. import com.tyyd.opensms.commons.utils.lang.ByteFormat;
  3.  
  4. import java.util.Map;
  5.  
  6.  
  7. public class RSATester {
  8.  
  9.     static String publicKey;
  10.     static String privateKey;
  11.  
  12.     static {
  13.         try {
  14.             Map<String, Object> keyMap = RSAUtils.genKeyPair();
  15.             publicKey = RSAUtils.getPublicKey(keyMap);
  16.             privateKey = RSAUtils.getPrivateKey(keyMap);
  17.             System.err.println("公钥: \t" + publicKey);
  18.             System.err.println("私钥： \t" + privateKey);
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.     
  24.     public static void main(String[] args) throws Exception {
  25.         test();
  26.         testSign();
  27.     }
  28.  
  29.     static void test() throws Exception {
  30.         System.err.println("公钥加密——私钥解密");
  31.         String source = "这是一行没有任何意义的文字，你看完了等于没看，不是吗？是不是感觉还是不够长啊，那咱们就再加点呗，现在肯定是超过了RSA的深度了。";
  32.         System.out.println("加密前文字：\t" + source);
  33.         byte[] encodedData = RSAUtils.encryptByPublicKey(source.getBytes(), publicKey);
  34.         System.out.println("加密后文字：\t" + new String(encodedData));
  35.         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
  36.         String target = new String(decodedData);
  37.         System.out.println("解密后文字: \t" + target);
  38.     }
  39.  
  40.     static void testSign() throws Exception {
  41.         System.err.println("私钥加密——公钥解密");
  42.         String source = "这是一行测试RSA数字签名的无意义文字。当然了，如果也觉得不够长，那就让它长长点，再长点，再长点，这回够长了吧，爽了吧！！";
  43.         System.out.println("原文字：\r\n" + source);
  44.         byte[] data = source.getBytes();
  45.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
  46.         System.out.println("加密后：\r\n" + ByteFormat.bytesToHexString(encodedData));
  47.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
  48.         String target = new String(decodedData);
  49.         System.out.println("解密后: \r\n" + target);
  50.         System.err.println("私钥签名——公钥验证签名");
  51.         String sign = RSAUtils.sign(encodedData, privateKey);
  52.         System.err.println("签名:\t" + sign);
  53.         boolean status = RSAUtils.verify(encodedData, publicKey, sign);
  54.         System.err.println("验证结果:\r" + status);
  55.     }
  56.     
  57. }

运行结果： 

  1. 公钥: 	MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCA2YZZH4++6UK6s3jkqhL7LJ1Tx5S+4Iex/PggH3GqswmSW4Vwpop87Ivdg7iBKj5k6q4W0W269LLgSLVHiYmGN4p4XhMJHgZ3hDfJNpPRnRQcC9Kqrol70Yp/rNpNESIZAI2pIZzzHiw6nj0/MCNVU0xM3Sal/H7RUjkiTtNpZQIDAQAB
  2. 私钥： 	MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIDZhlkfj77pQrqzeOSqEvssnVPHlL7gh7H8+CAfcaqzCZJbhXCminzsi92DuIEqPmTqrhbRbbr0suBItUeJiYY3inheEwkeBneEN8k2k9GdFBwL0qquiXvRin+s2k0RIhkAjakhnPMeLDqePT8wI1VTTEzdJqX8ftFSOSJO02llAgMBAAECgYAaeBUgQ9qMtnBt2CaSmtmRXaXoKwzEdW2Kw9PZDXyVO3hQ55ou/Rdf+Fv3InMJnbr5kjg3Gci36kLAzk7nJjro2+IDtKrAQaVlsdim1/cDa9Aer+U1EdVugoniHOmtOQWA8lLF6XS3epx6U4XTNFFQmyH4vwHLiiXgO/ThV4H7gQJBALtlab+9CfTJgIjbP+gyStGhW1/6GzwRLnl/sOcLmCN95ii0dDe/xrpTVQNCOMmjqvIG/EPLkklIGevWNoqpWsUCQQCwBTIWcgugnxN7GSJAchTSVyb42+hcYkawb5NCZfM6OGcZkeVLBODMgc8cTJrZMBHjuOQK2LL9jgbAyCurJz4hAkAeLlAgxFZlKUrdP8qEIA1yw7UOuR5Hx1Cf2tPn8jMXjEBUT/PjwqxD+AXaF4FD4Gs4va1FUfUGfmlGVWLFZE8tAkB0YbsQZC+T8BotVhzzh3qE6OL3wE8OZlxe5Cb1y/raD9j7ax+0TnFkRp/uEiiAWew6KVF+anFOfM2yQae97qCBAkAVXIQ3Kbh8E8biHV/6DJ4MvvLWa5g+bP41Y4i7x9IK5AQytCmvGvO9qSxQZiWGpt+h0e8Oh2/qC+CQispFAQvv
  3. 公钥加密——私钥解密
  4. 加密前文字：	这是一行没有任何意义的文字，你看完了等于没看，不是吗？是不是感觉还是不够长啊，那咱们就再加点呗，现在肯定是超了的。
  5. O�v,�Sm�ƫ��*x�r}�O|v��U�J ��dݗ3�O��O�%�N��L]�Ļ\	F���s$��_jZ�f#���J��
  6. 解密后文字: 	这是一行没有任何意义的文字，你看完了等于没看，不是吗？是不是感觉还是不够长啊，那咱们就再加点呗，现在肯定是超了的。
  7. 私钥加密——公钥解密
  8. 原文字：
  9. 这是一行测试RSA数字签名的无意义文字。当然了，如果也觉得不够长，那就让它长长点，再长点，再长点，这回够长了吧，爽了吧！！
  10. 加密后：
  11. 29F056E28E0C3F9BC20FBD8AF34C20E4EAF9AD9047879929FB5D72B9F29336D6D64E1ED2A9AD32442F851EC022746EDB0E36A3159E793EB3E456EDB5E18B52F0AAD4CD6A35B2548BCFC87D24D6DEEBC613508CF9FEB7C211D9AC4CC552BEF785498C19475CC8D086A5B9A12E41BE9280EAFF589B13BD5A4FE0F4DCB5B4F3DC0E69CC5678AEC002490272BEC24706E5C051D139D039B767462F1E7850451E136A045F403665292ED630E7A284E740BBC111572783818A3382E7A8485E9EE13CF0037A65ECD6C60BC52526CD7D190E1350962EB3ABF4A51C8F0DDC88F0B3A8F08DBB047F4C8D998F6A31335B4C6F5B6E2C397D42BAD05A19FA4B18315612514023
  12. 解密后: 
  13. 这是一行测试RSA数字签名的无意义文字。当然了，如果也觉得不够长，那就让它长长点，再长点，再长点，这回够长了吧，爽了吧！！
  14. 私钥签名——公钥验证签名
  15. 签名:	XT7O9Xj6aXP0jW9C7ocUj7jRpQr1ONAOAl6VYm1igPPunGdDLvCbOzjDFng4fdlJ58pUud/yq5av0bk5HUlWNulBGY6wa1uTjcsJwoARlV8j/0N8JXrKn/sngIG6ewWIFQOTzn7MHL6g3NMeYifAWb2Lc5FLv85cU94nkzqagGY=
  16. true
  17.  
  18. Process finished with exit code 0

 

 

 抄自：https://blog.csdn.net/centralperk/article/details/8538697

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/202881
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号