之前发了一篇”TripleDes的加解密Java、C#、php通用代码”，后面又有项目用到了Rsa加解密，还是在不同系统之间进行交互，Rsa在不同语言的密钥格式不一样，所以过程中主要还是密钥转换问题，为方便密钥转换，写了一个XML和PEM格式的密钥转换工具，文章后面会提供密钥转换工具的下载地址，通过搜索参考和研究终于搞定了在Java、C#和Php都可以通用的加解密代码，整理了Rsa的加解密代码做个记录，以后可以参考，大家应该都知道Rsa算法，这里就不说明了，直接看代码（代码主要是公钥加密私钥解密，密文统一进行base64编码，密钥长度为2048）：

Java版本：

  1. package com.jaamy.common.util;
  3. import java.io.BufferedReader;
  4. import java.io.ByteArrayOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.IOException;
  7. import java.io.InputStream;
  8. import java.io.InputStreamReader;
  9. import java.security.Key;
  10. import java.security.KeyFactory;
  11. import java.security.spec.PKCS8EncodedKeySpec;
  12. import java.security.spec.X509EncodedKeySpec;
  14. import javax.crypto.Cipher;
  16. import org.apache.commons.codec.binary.Base64;
  18. public class RSACryptoUtil {
  20.     /**
  21.      * 加密算法RSA
  22.      */
  23.     public static final String KEY_ALGORITHM = "RSA";
  24.     /**
  25.      * 填充方式
  26.      */
  27.     public static final String CIPHER_TRANSFORMAT = "RSA/ECB/PKCS1Padding";
  28.     
  29.     /**
  30.      * RSA最大加密明文大小
  31.      */
  32.     private static final int MAX_ENCRYPT_BLOCK = 245;
  33.     
  34.     /**
  35.      * RSA最大解密密文大小
  36.      */
  37.     private static final int MAX_DECRYPT_BLOCK = 256;
  38.     
  39.     /**
  40.      * 公钥加密
  41.      * @param content  原文
  42.      * @param publicKey  公钥
  43.      * @param inputCharset 字符编码
  44.      * @return  加密后的字符串（base64）
  45.      * @throws Exception
  46.      */
  47.     public static String encryptByPublicKey(String content, String publicKey, String inputCharset)
  48.             throws Exception {
  50.         byte[] data = content.getBytes(inputCharset);
  51.         byte[] keyBytes = Base64.decodeBase64(publicKey);
  52.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
  53.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  54.         Key publicK = keyFactory.generatePublic(x509KeySpec);
  55.         
  56.         // 对数据加密
  57.         Cipher cipher = Cipher.getInstance(CIPHER_TRANSFORMAT);
  58.         cipher.init(Cipher.ENCRYPT_MODE, publicK);
  59.         int inputLen = data.length;
  60.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  61.         int offSet = 0;
  62.         byte[] cache;
  63.         int i = 0;
  64.         // 对数据分段加密
  65.         while (inputLen - offSet > 0) {
  66.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
  67.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
  68.             } else {
  69.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
  70.             }
  71.             out.write(cache, 0, cache.length);
  72.             i++;
  73.             offSet = i * MAX_ENCRYPT_BLOCK;
  74.         }
  75.         byte[] encryptedData = out.toByteArray();
  76.         out.close();
  77.         
  78.         return Base64.encodeBase64String(encryptedData);
  79.     }
  80.     
  81.     /**
  82.      * 私钥解密
  83.      * @param content  密文（base64）
  84.      * @param privateKey  私钥
  85.      * @param inputCharset  字符编码
  86.      * @return
  87.      * @throws Exception
  88.      */
  89.     public static String decryptByPrivateKey(String content,
  90.             String privateKey, String inputCharset) throws Exception {
  91.         
  92.         byte[] encryptedData = Base64.decodeBase64(content);
  93.         byte[] keyBytes = Base64.decodeBase64(privateKey);
  94.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
  95.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
  96.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
  97.         
  98.         Cipher cipher = Cipher.getInstance(CIPHER_TRANSFORMAT);
  99.         cipher.init(Cipher.DECRYPT_MODE, privateK);
  100.         int inputLen = encryptedData.length;
  101.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  102.         int offSet = 0;
  103.         byte[] cache;
  104.         int i = 0;
  105.         // 对数据分段解密
  106.         while (inputLen - offSet > 0) {
  107.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
  108.                 cache = cipher
  109.                         .doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
  110.             } else {
  111.                 cache = cipher
  112.                         .doFinal(encryptedData, offSet, inputLen - offSet);
  113.             }
  114.             out.write(cache, 0, cache.length);
  115.             i++;
  116.             offSet = i * MAX_DECRYPT_BLOCK;
  117.         }
  118.         byte[] decryptedData = out.toByteArray();
  119.         out.close();
  120.         return new String(decryptedData, inputCharset);
  121.     }
  122.     
  123.     /**
  124.      * 从文件中加载密钥字符串
  125.      * @return 是否成功
  126.      * @throws Exception
  127.      */
  128.     public static String loadKeyString(String keyFile){
  129.         String keyString="";
  130.         InputStream in=null;
  131.         BufferedReader br=null;
  132.         try {
  133.             in=RSACryptoUtil.class.getResourceAsStream("/"+keyFile);
  134.             br= new BufferedReader(new InputStreamReader(in));
  135.             String readLine= null;
  136.             StringBuilder sb= new StringBuilder();
  137.             while((readLine= br.readLine())!=null){
  138.                 if(readLine.charAt(0)==\'-\'){
  139.                     continue;
  140.                 }else{
  141.                     sb.append(readLine);
  142.                     sb.append(\'\r\');
  143.                 }
  144.             }
  145.             keyString=sb.toString();
  146.         } catch (IOException e) {
  147.         } catch (Exception e) {
  149.         }finally{
  150.             if(br!=null){
  151.                 try {
  152.                     br.close();
  153.                 } catch (IOException e) {
  154.                 }
  155.             }
  156.             if(in!=null){
  157.                 try {
  158.                     in.close();
  159.                 } catch (IOException e) {
  160.                 }
  161.             }
  162.         }
  163.         return keyString;
  164.     }
  165.     
  166.     /**
  167.      * 从文件中加载密钥字符串  根据文件路径加载
  168.      * @return 是否成功
  169.      * @throws Exception
  170.      */
  171.     public static String loadKeyStringByPath(String keyFile){
  172.         String keyString="";
  173.         InputStream in=null;
  174.         BufferedReader br=null;
  175.         try {
  176.             in = new FileInputStream(keyFile);
  177.             br= new BufferedReader(new InputStreamReader(in));
  178.             String readLine= null;
  179.             StringBuilder sb= new StringBuilder();
  180.             while((readLine= br.readLine())!=null){
  181.                 if(readLine.charAt(0)==\'-\'){
  182.                     continue;
  183.                 }else{
  184.                     sb.append(readLine);
  185.                     sb.append(\'\r\');
  186.                 }
  187.             }
  188.             keyString=sb.toString();
  189.         } catch (IOException e) {
  190.             System.out.println(e.getMessage());
  191.         } catch (Exception e) {
  192.             System.out.println(e.getMessage());
  194.         }finally{
  195.             if(br!=null){
  196.                 try {
  197.                     br.close();
  198.                 } catch (IOException e) {
  199.                 }
  200.             }
  201.             if(in!=null){
  202.                 try {
  203.                     in.close();
  204.                 } catch (IOException e) {
  205.                 }
  206.             }
  207.         }
  208.         return keyString;
  209.     }
  210.     
  211.     public static void main(String[] args) throws Exception {
  212.         String publicKey = RSAUtils.loadKeyStringByPath("D:/sso_public_key_test.pem");
  213.         System.out.println(RSACryptoUtil.encryptByPublicKey("123", publicKey, "utf-8"));
  214.     }
  215. }

 

C#版本：

  1. /// <summary>
  2. /// RSA加密+base64
  3. /// </summary>
  4. /// <param name="publickey">公钥</param>
  5. /// <param name="content">原文</param>
  6. /// <returns>加密后的密文字符串</returns>
  7. public static string RSAEncrypt(string publickey, string content)
  8. {
  9.     //最大文件加密块
  10.     int MAX_ENCRYPT_BLOCK = 245;
  12.     RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
  13.     byte[] cipherbytes;
  14.     rsa.FromXmlString(publickey);
  15.     byte[] contentByte = Encoding.UTF8.GetBytes(content);
  16.     int inputLen = contentByte.Length;
  18.     int offSet = 0;
  19.     byte[] cache;
  20.     int i = 0;
  21.     System.IO.MemoryStream aMS = new System.IO.MemoryStream();
  22.     // 对数据分段加密
  23.     while (inputLen - offSet > 0)
  24.     {
  25.         byte[] temp = new byte[MAX_ENCRYPT_BLOCK];
  26.         if (inputLen - offSet > MAX_ENCRYPT_BLOCK)
  27.         {
  28.             Array.Copy(contentByte, offSet, temp, 0, MAX_ENCRYPT_BLOCK);
  29.             cache = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
  30.         }
  31.         else
  32.         {
  33.             Array.Copy(contentByte, offSet, temp, 0, inputLen - offSet);
  34.             cache = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
  35.         }
  36.         aMS.Write(cache, 0, cache.Length);
  37.         i++;
  38.         offSet = i * MAX_ENCRYPT_BLOCK;
  39.     }
  41.     cipherbytes = aMS.ToArray();
  42.     return Convert.ToBase64String(cipherbytes);
  43. }
  44.         
  45. /// <summary>
  46. /// RSA解密
  47. /// </summary>
  48. /// <param name="privatekey">私钥</param>
  49. /// <param name="content">密文（RSA+base64）</param>
  50. /// <returns>解密后的字符串</returns>
  51. public static string RSADecrypt(string privatekey, string content)
  52. {
  53.     //最大文件解密块
  54.     int MAX_DECRYPT_BLOCK = 256;
  56.     RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
  57.     byte[] cipherbytes;
  58.     rsa.FromXmlString(privatekey);
  59.     byte[] contentByte = Convert.FromBase64String(content);
  60.     int inputLen = contentByte.Length;
  62.     // 对数据分段解密
  63.     int offSet = 0;
  64.     int i = 0;
  65.     byte[] cache;
  66.     System.IO.MemoryStream aMS = new System.IO.MemoryStream();
  67.     while (inputLen - offSet > 0)
  68.     {
  69.         byte[] temp = new byte[MAX_DECRYPT_BLOCK];
  70.         if (inputLen - offSet > MAX_DECRYPT_BLOCK)
  71.         {
  72.             Array.Copy(contentByte, offSet, temp, 0, MAX_DECRYPT_BLOCK);
  73.             cache = rsa.Decrypt(temp, false);
  74.         }
  75.         else
  76.         {
  77.             Array.Copy(contentByte, offSet, temp, 0, inputLen - offSet);
  78.             cache = rsa.Decrypt(temp, false);
  79.         }
  80.         aMS.Write(cache, 0, cache.Length);
  81.         i++;
  82.         offSet = i * MAX_DECRYPT_BLOCK;
  83.     }
  84.     cipherbytes = aMS.ToArray();
  86.     return Encoding.UTF8.GetString(cipherbytes);
  87. }

 

Php版本：

  1. <?php
  2. #私钥
  3. $private_key = \'-----BEGIN PRIVATE KEY-----
  4. MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCocmvQIWD2L9TW
  5. N1uKpLONwHcdy2oaKoW1CtI8PB+S+UjdEuLl3usWEuh3ZgLYloPyD9553SJFn7an
  6. fOplHITBqASOIXt9pi0CkahUPgwCPj4Dke5cT3fsp2i243/FX3afzrcf7FfTrEv/
  7. LT22wF3csqrGt/UhqMcmpWIpPaL8edoCwGRBhghzEWaRwPZ2x5RPg+9qTSy0M7QG
  8. u+8EwYDnNkGGuuIwzNxklclic9Unp96eVp33vOP/LNvz90OcuqGQQcABh+e2ttv6
  9. VzqlRcD1GRhxqkT3erXmgbQAVm6JQHArK1Up10No+lth1tri5TGcL0BEF7PetDIj
  10. jYh+aCLpAgMBAAECggEAPjFI1yaLyzmrxo/Xz5+x36NxF2IUQabziP1+09iK+9Po
  11. cB9aAO9GMvc2N2dFo7wm6Uesp6fa0IQAh2RakoxuA6ZKUEPSeXjSY4Ft+fSSsH1U
  12. njLSI+j/aTQCOIxUj4YIoUZMXJABeVjDEmscvw3VWffpj8c5zXyoUv9696kXNUoa
  13. uHOuphe1UNc3ghFIpWK+7ScxkPB6KtmAFwD4LSbT9OwhPozavBqouQvhLt1bXO8C
  14. ycKq4f1Pzhtt3sq3BRsPwqGhWt1NK95upKQuDnk1kJHjNzScH1FZxhsBHLxwOJ6E
  15. M7HP5Ywh78umusaNPVLMM6+YVWbENg+WZZcXd/XspQKBgQDRIhIukY7m7fRBH0CP
  16. mHi20gUmn7HzXgLxlbcU5n2PMDHHOg8D+Nmz1MnYPRQNwqxJdH8HOk8YQDC2uA+h
  17. BpyCpvPbp6y6SnZw8bhqiNfSHBjEftmg7lUU5xzBiBo6SyCyLkWD2xa/O8Vyh6ut
  18. /G1mQpNNJWWt5b+g5c4i0/fIhwKBgQDOMjGcLS8zHnZ30ZsWUS39iZ5TZXPCldTl
  19. Q9JB5PnB4CajYmQEdw3n9C6mOO42b+3M04mmqo1r0HiNyA9lZQQNsM3KqG+ngGvE
  20. 0DM1cAyuz3Fi3XTIhAbRyXXyVbqBp5Yh2/O2lvrsInusJrimDRgwglquu2GsdVrj
  21. +++b2DFFDwKBgQCkfXLlk/FdK44xZn5mM1vHGBubDIJv0+Lm14Yf90aMyDBu7fh/
  22. fEznSBfWb/wE8riGMg3zxmYNwfdO0Cji04torB4kB5cxE35jSYxupuFxzk2gx9Eu
  23. 5iafgUQ56G4QqaS24PQmSL10fnPHqHRdLa1ygCzRwfdettVpnTbsZ+J9owKBgQDF
  24. o2Tb3o9sPxmsdVNiy8L6TstcAlU3wOfELQK+uFwQ0eoXFvrpMLg6iVmhZ9YkhZp4
  25. hpZdEwLkwXib5ZOkS3PcL4jBZDtJYRVrG2jKIrF1aU60RbJnc+0ZbjHIaxWOqvSD
  26. VdE/RW4TomXKN38rYke6T2feLatMY1wQRG6BgXKQTwKBgQDKfK9Xuqzx+WI4AohT
  27. EwKrQEZUMD+6DTESHHG9As4zMJ9zU+6iPpM4Gw4CzfJZHhPP4dD+TC9NcvvR+GC9
  28. UkwxmZrvP1+6KNFp0DZNk6M9wPZuYM/E63Vy0sFEA+/gFp4vQh8k7N8n/n7DhR3v
  29. kLuPdicfsKcz0thxzyDjv6oR2g==
  30. -----END PRIVATE KEY-----\';
  32. #公钥
  33. $public_key = \'-----BEGIN PUBLIC KEY-----
  34. MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqHJr0CFg9i/U1jdbiqSz
  35. jcB3HctqGiqFtQrSPDwfkvlI3RLi5d7rFhLod2YC2JaD8g/eed0iRZ+2p3zqZRyE
  36. wagEjiF7faYtApGoVD4MAj4+A5HuXE937KdotuN/xV92n863H+xX06xL/y09tsBd
  37. 3LKqxrf1IajHJqViKT2i/HnaAsBkQYYIcxFmkcD2dseUT4Pvak0stDO0BrvvBMGA
  38. 5zZBhrriMMzcZJXJYnPVJ6fenlad97zj/yzb8/dDnLqhkEHAAYfntrbb+lc6pUXA
  39. 9RkYcapE93q15oG0AFZuiUBwKytVKddDaPpbYdba4uUxnC9ARBez3rQyI42Ifmgi
  40. 6QIDAQAB
  41. -----END PUBLIC KEY-----\';
  43. $pi_key = openssl_pkey_get_private($private_key);
  44. $pu_key = openssl_pkey_get_public($public_key);
  47. #公钥加密数据 rsa+base64
  48. $data = "hello world!";
  49. openssl_public_encrypt($data,$encrypted,$pu_key);
  50. $base64_encrypted = base64_encode($encrypted);
  51. echo $base64_encrypted."\n";
  53. #私钥解密数据
  54. openssl_private_decrypt(base64_decode($base64_encrypted),$decrypted_data,$pi_key);
  56. echo $decrypted_data;
  58. ?>

 

Rsa加解密C#和Java、php使用的密钥格式不一样，这里提供一个密钥转换工具：Rsa密钥转换工具v2.0.zip

 

版权声明：本文为jaamy原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jaamy/archive/2016/12/02/6118814.html