BouncyCastle RSA加解密类 C#版 兼容JAVA PHP（RSAHelper）

C# RSAHelper类 实现兼容JAVA，PHP的RSA加解密类

View Code

  1  ///   <summary>
  2       ///  杨鑫
  3       ///  2012年10月29日
  4       ///   </summary>
  5       public  class RSAHelper
  6     {
  7          ///   <summary>
  8           ///  数据加密处理
  9           ///   </summary>
 10           ///   <param name="text"></param>
 11           ///   <returns></returns>
 12           public  static  string EncryptRSA( string text)
 13         {
 14              string value =  "";
 15              //  System.out.println("encrypt-start:-----------------------------------------------------");
 16               try
 17             {
 18                  // 非空验证
 19                   if (! string.IsNullOrEmpty(text))
 20                 {
 21                      string publicKey =  " PublicKey.pem ";
 22 
 23                      #region 分段加密 解决加密明文过长问题
 24 
 25                      // 将字符串转为UTF8编码
 26                      text = Convert.ToBase64String(Encoding.GetEncoding( " utf-8 ").GetBytes(text));
 27                     text = text.Replace( " \r ",  "").Replace( " \n ",  "");
 28 
 29                      int len =  117;
 30                      int m = text.Length / len;
 31                      if (m * len != text.Length)
 32                     {
 33                         m = m +  1;
 34                     }
 35 
 36                      for ( int i =  0; i < m; i++)
 37                     {
 38                          string temp =  "";
 39 
 40                          if (i < m -  1)
 41                         {
 42                             temp = text.Substring(i * len, len); // (i + 1) * len
 43                          }
 44                          else
 45                         {
 46                             temp = text.Substring(i * len);
 47                         }
 48 
 49                         temp = Convert.ToBase64String(Encrypt(Encoding.GetEncoding( " utf-8 ").GetBytes(temp), publicKey));
 50                         temp = temp.Replace( " \r ",  "").Replace( " \n ",  "");
 51 
 52                         value += temp;
 53                     }
 54 
 55                      #endregion
 56                 }
 57             }
 58              catch (Exception e)
 59             {
 60                 MessageBox.Show(e.Message);
 61             }
 62 
 63              //  System.out.println("encrypt-end:-----------------------------------------------------");
 64 
 65              return value;
 66         }
 67 
 68          ///   <summary>
 69           ///  数据解密处理
 70           ///   </summary>
 71           ///   <param name="text"></param>
 72           ///   <returns></returns>
 73           public  static  string DecryptRSA( string text)
 74         {
 75              string value =  "";
 76              //  System.out.println("decrypt-start:-----------------------------------------------------");
 77               try
 78             {
 79                  if (! string.IsNullOrEmpty(text))
 80                 {
 81                      // 密码文件名
 82                       string password =  " Password.pem ";
 83                      // 私钥文件名
 84                       string privateKey =  " PrivateKey.pem ";
 85 
 86                      #region 分段解密 解决加密密文过长问题
 87                      int len =  172;
 88                      int m = text.Length / len;
 89                      if (m * len != text.Length)
 90                     {
 91                         m = m +  1;
 92                     }
 93 
 94                      for ( int i =  0; i < m; i++)
 95                     {
 96                          string temp =  "";
 97 
 98                          if (i < m -  1)
 99                         {
100                             temp = text.Substring(i * len, len);
101                         }
102                          else
103                         {
104                             temp = text.Substring(i * len);
105                         }
106 
107                          // 解决PHP中文问题
108                          temp = decode64(temp);
109 
110                         temp = Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(temp), privateKey, password));
111                         value += temp;
112 
113                     }
114                      #endregion
115 
116                      // 解决PHP中文问题
117                      value = decode64(value);
118                     value = Encoding.UTF8.GetString(Convert.FromBase64String(value));
119                 }
120             }
121              catch (Exception e)
122             {
123                 MessageBox.Show(e.Message);
124             }
125              //  System.out.println("decrypt-end:-----------------------------------------------------");
126 
127              return value;
128         }
129 
130          ///   <summary>
131           ///  RSA加密操作 Encrypt方法
132           ///   </summary>
133           ///   <param name="DataToEncrypt"></param>
134           ///   <param name="publicKey"></param>
135           ///   <returns></returns>
136           private  static  byte[] Encrypt( byte[] DataToEncrypt,  string publicKey)
137         {
138              try
139             {
140                 PemReader r =  new PemReader( new StreamReader(publicKey)); // 载入公钥文件
141                  Object readObject = r.ReadObject();
142                  // 实例化参数实例
143                  AsymmetricKeyParameter pubKey = (AsymmetricKeyParameter)readObject;
144                 IBufferedCipher c = CipherUtilities.GetCipher( " RSA/ECB/PKCS1Padding "); //  参数与JAVA中解密的参数一致
145                  c.Init( true, pubKey);
146 
147                  // int blockSize = c.GetBlockSize();
148                   // c.ProcessBytes(DataToEncrypt);
149 
150                  byte[] outBytes = c.DoFinal(DataToEncrypt);
151                  return outBytes;
152             }
153              catch (Exception e)
154             {
155                 MessageBox.Show(e.Message);
156             }
157 
158              return  null;
159         }
160 
161          ///   <summary>
162           ///  RSA解密操作 Decrypt方法
163           ///   </summary>
164           ///   <param name="input"></param>
165           ///   <param name="privateKey"></param>
166           ///   <param name="password"></param>
167           ///   <returns></returns>
168           private  static  byte[] Decrypt( byte[] input,  string privateKey,  string password)
169         {
170              try
171             {
172                 PemReader r =  new PemReader( new StreamReader(privateKey),  new Password( new StreamReader(password).ReadToEnd().ToCharArray()));      // 载入私钥
173                  Object readObject = r.ReadObject();
174                 AsymmetricKeyParameter priKey = (AsymmetricKeyParameter)readObject;
175                 IBufferedCipher c = CipherUtilities.GetCipher( " RSA/ECB/PKCS1Padding ");
176                 c.Init( false, priKey);
177 
178                  // int blockSize = c.GetBlockSize();
179                   // c.ProcessBytes(input);
180 
181                  byte[] outBytes = c.DoFinal(input);
182                  return outBytes;
183             }
184              catch (Exception e)
185             {
186                 MessageBox.Show(e.Message);
187             }
188              return  null;
189         }
190 
191          ///   <summary>
192           ///  解决PHP Base64编码后回车问题 
193           ///   </summary>
194           ///   <param name="text"></param>
195           ///   <returns></returns>
196           public  static String decode64(String text)
197         {
198             String value =  "";
199 
200              try
201             {
202                 text =  string.IsNullOrEmpty(text) ?  "" : text;
203 
204                  int len =  64;
205                  int m = text.Length / len;
206                  if (m * len != text.Length)
207                 {
208                     m = m +  1;
209                 }
210 
211                  for ( int i =  0; i < m; i++)
212                 {
213                     String temp =  "";
214 
215                      if (i < m -  1)
216                     {
217                         temp = text.Substring(i * len, len); // (i + 1) * len
218                          value += temp +  " \r\n ";
219                     }
220                      else
221                     {
222                         temp = text.Substring(i * len);
223                         value += temp;
224                     }
225                 }
226             }
227              catch (Exception e)
228             {
229                 MessageBox.Show(e.Message);
230             }
231 
232              return value;
233         }
234     }
235 
236      ///   <summary>
237       ///  BouncyCastle 密钥类
238       ///   </summary>
239       public  class Password : IPasswordFinder
240     {
241          private  char[] password;
242 
243          public Password( char[] word)
244         {
245              this.password = ( char[])word.Clone();
246         }
247 
248          public  char[] GetPassword()
249         {
250              return ( char[])password.Clone();
251         }
252     }

JAVA下的加解密过程 实例代码：

 

View Code

  1  package com.jjlg.webinf;
  2 
  3  import java.io.File;
  4  import java.io.FileReader;
  5  import java.security.Key;
  6  import java.security.SecureRandom;
  7  import java.security.Security;
  8 
  9  import javax.crypto.Cipher;
 10 
 11  import org.bouncycastle.jce.provider.BouncyCastleProvider;
 12  import org.bouncycastle.openssl.PEMReader;
 13  import org.bouncycastle.openssl.PasswordFinder;
 14 
 15  import com.jjlg.MyFile;
 16  import com.jjlg.MyString;
 17 
 18  import sun.misc.BASE64Decoder;
 19  import sun.misc.BASE64Encoder;
 20 
 21  /**
 22   * RSA算法，实现数据的加密解密。
 23   * 
 24   *  @author  ShaoJiang
 25   * 
 26    */
 27  public  class PhpRsa
 28 {
 29 
 30      public  static  void main(String[] args)
 31     {
 32          try
 33         {
 34 
 35              //  字符串截取测试
 36               //  String str = "1234567890";
 37               //  System.out.println(str.substring(0, 5));
 38               //  System.out.println(str.substring(5, 10));
 39 
 40               //  加密解密测试
 41              String text = "一二三四五六七八九十1234567890一二三四五六七八九十1234567890一二三四五六七八九十1234567890一二三四五六七八九十1234567890一二三四五六七八九十1234567890";
 42             String encodeString = PhpRsa.encrypt(text);
 43             String decodeString = PhpRsa.decrypt(encodeString);
 44 
 45             System.out.println("text=" + text);
 46             System.out.println("encodeString=" + encodeString);
 47             System.out.println("decodeString=" + decodeString);
 48 
 49             String p = "gO9NZbjwx7bf+MfWPKYP2WkZI72jUwz/EC031V+WkWLEigo04vbvsRyPxv0wJYYVuJ3xQk7OgonTWYfDa3EGXVN45j64SMhxhOdN5242h+ke3GJpyrBUWi/waVc/conAL46sNe6tCtGW7iU/EOl415XoUTX6ns7LdHDRPsxj3d8=";
 50             System.out.println(PhpRsa.decrypt(p));
 51 
 52              //  String zi =
 53               //  "山西省太原市小店区abc山西省太原市小23店区平阳路与平阳路西二efa巷交叉口往北米新康隆456商城好的789你好";
 54               //  zi = new String(zi.getBytes(), "utf-8");
 55               //  System.out.println(zi);
 56               //
 57               //  String t = (new BASE64Encoder()).encode(zi.getBytes("utf-8"));
 58               //  String w = new String((new BASE64Decoder()).decodeBuffer(new
 59               //  String(t.getBytes())), "utf-8");
 60               //  String e = t.replace("\r\n", ""); //
 61               //  "5bGx6KW/55yB5aSq5Y6f5biC5bCP5bqX5Yy6YWJj5bGx6KW/55yB5aSq5Y6f5biC5bCPMjPlupfljLrlubPpmLPot6/kuI7lubPpmLPot6/opb/kuoxlZmHlt7fkuqTlj4nlj6PlvoDljJfnsbPmlrDlurfpmoY0NTbllYbln47lpb3nmoQ3ODnkvaDlpb0=";
 62               //  e = new String((new BASE64Decoder()).decodeBuffer(e));
 63               //  t = t.replace("\r\n", "");
 64               //  System.out.println(t);
 65               //  System.out.println(t.length());
 66               //  System.out.println(w);
 67               //  System.out.println(w.length());
 68               //  System.out.println(new String(e.getBytes(), "utf-8"));
 69 
 70               //  中文编码测试
 71               //  String str = "王某某";
 72               //  System.out.println("1:" + new String(str.getBytes("utf-8"),
 73               //  "gb2312"));
 74 
 75               //  System.out.println("1:" + new String(str.getBytes("gb2312"),
 76               //  "utf-8"));
 77 
 78               //  String str2 =
 79               //  "o0glTLeRAaE1LYj6P/jHPQrzUhKozQWSDHSkyv+HbyluAIE7Ao3KPXGWMG2Rg7SAY+G6yCuOQn4DAmwM4QnbQn+I/CUUVCcz8JTco6S6++3I2luZfTMYee6e+KsC+YHXY2VinJ7ubN6hCtKWLckbC68oXBXtKEHfPQ48vZnmcWk=";
 80               //  System.out.println(PhpRsa.decrypt(str2));
 81 
 82         }
 83          catch (Exception e)
 84         {
 85             e.printStackTrace();
 86         }
 87     }
 88 
 89      public  static String encrypt(String text)
 90     {
 91         String value = "";
 92 
 93          //  System.out.println("encrypt-start:-----------------------------------------------------");
 94 
 95          try
 96         {
 97              if (text !=  null && text.length() > 0 && !text.equals(""))
 98             {
 99                 Security.addProvider( new BouncyCastleProvider());
100 
101                 PhpRsa rsa =  new PhpRsa();
102                 String path = rsa.getClass().getResource("").getPath();
103                  //  System.out.println(path + "PublicKey.pem");
104                  Key publicKey = translatePublicKey( new File(path + "PublicKey.pem"));
105 
106                 text = ( new BASE64Encoder()).encode(text.getBytes("utf-8"));
107                 text = text.replace("\r", "");
108                 text = text.replace("\n", "");
109                  //  System.out.println(text);
110 
111                  int len = 117;
112                  int m = text.length() / len;
113                  if (m * len != text.length())
114                 {
115                     m = m + 1;
116                 }
117 
118                  for ( int i = 0; i < m; i++)
119                 {
120                     String temp = "";
121 
122                      if (i < m - 1)
123                     {
124                         temp = text.substring(i * len, (i + 1) * len);
125                     }
126                      else
127                     {
128                         temp = text.substring(i * len);
129                     }
130 
131                      //  System.out.println(temp);
132                       //  System.out.println(temp.length());
133 
134                     temp = ( new BASE64Encoder()).encode(PhpRsa.encrypt(temp.getBytes(), publicKey));
135                     temp = temp.replace("\r", "");
136                     temp = temp.replace("\n", "");
137 
138                     value += temp;
139                 }
140 
141                  //  System.out.println("encrypt-text:" + text);
142                   //  System.out.println("encrypt-value:" + value);
143              }
144 
145         }
146          catch (Exception e)
147         {
148             e.printStackTrace();
149         }
150 
151          //  System.out.println("encrypt-end:-----------------------------------------------------");
152 
153          return value;
154     }
155 
156      public  static String decrypt(String text)
157     {
158         String value = "";
159 
160          //  System.out.println("decrypt-start:-----------------------------------------------------");
161 
162          try
163         {
164              if (text !=  null && text.length() > 0 && !text.equals(""))
165             {
166                 Security.addProvider( new BouncyCastleProvider());
167 
168                 PhpRsa rsa =  new PhpRsa();
169                 String path = rsa.getClass().getResource("").getPath();
170                 String password = MyFile.readTxt(path + "Password.pem", "utf-8").replace("\n", "");
171 
172                 Key privateKey = translatePrivateKey( new File(path + "PrivateKey.pem"), password);
173 
174                  //  分段解密
175                   int len = 172;
176                  int m = text.length() / len;
177                  if (m * len != text.length())
178                 {
179                     m = m + 1;
180                 }
181 
182                  for ( int i = 0; i < m; i++)
183                 {
184                     String temp = "";
185 
186                      if (i < m - 1)
187                     {
188                         temp = text.substring(i * len, (i + 1) * len);
189                     }
190                      else
191                     {
192                         temp = text.substring(i * len);
193                     }
194 
195                      //  System.out.println(temp);
196                       //  System.out.println(temp.length());
197                      temp = PhpRsa.decode64(temp);
198 
199                      //  System.out.println(temp);
200                       //  System.out.println(temp.length());
201 
202                     temp =  new String(PhpRsa.decrypt(( new BASE64Decoder()).decodeBuffer(temp), privateKey), "utf-8");
203 
204                      //  System.out.println(temp);
205                       //  System.out.println(temp.length());
206 
207                     value += temp;
208                 }
209 
210                 value = PhpRsa.decode64(value);
211                 value =  new String(( new BASE64Decoder()).decodeBuffer(value), "utf-8");
212 
213                  //  System.out.println("dencrypt-text:" + text);
214                   //  System.out.println("dencrypt-value:" + value);
215              }
216         }
217          catch (Exception e)
218         {
219             e.printStackTrace();
220         }
221 
222          //  System.out.println("decrypt-end:-----------------------------------------------------");
223 
224          return value;
225     }
226 
227      public  static String decode64(String text)
228     {
229         String value = "";
230 
231          try
232         {
233 
234             text = MyString.format(text);
235 
236              int len = 64;
237              int m = text.length() / len;
238              if (m * len != text.length())
239             {
240                 m = m + 1;
241             }
242 
243              for ( int i = 0; i < m; i++)
244             {
245                 String temp = "";
246 
247                  if (i < m - 1)
248                 {
249                     temp = text.substring(i * len, (i + 1) * len);
250                     value += temp + "\r\n";
251                 }
252                  else
253                 {
254                     temp = text.substring(i * len);
255                     value += temp;
256                 }
257             }
258 
259              //  System.out.println(value);
260 
261         }
262          catch (Exception e)
263         {
264             e.printStackTrace();
265         }
266 
267          return value;
268     }
269 
270      static  public Key translatePublicKey(File pem)
271     {
272          try
273         {
274             PEMReader reader =  new PEMReader( new FileReader(pem));
275             Key key = (Key) reader.readObject();
276             reader.close();
277 
278              return key;
279         }
280          catch (Exception e)
281         {
282             e.printStackTrace();
283         }
284 
285          return  null;
286     }
287 
288      static  public Key translatePrivateKey(File pem,  final String password)
289     {
290          try
291         {
292             PEMReader reader =  new PEMReader( new FileReader(pem),  new PasswordFinder()
293             {
294                  public  char[] getPassword()
295                 {
296                      return password.toCharArray();
297                 }
298             });
299             Key key = (Key) reader.readObject();
300             reader.close();
301              return key;
302         }
303          catch (Exception e)
304         {
305             e.printStackTrace();
306         }
307 
308          return  null;
309     }
310 
311      public  static  byte[] encrypt( byte[] input, Key publicKey)
312     {
313          try
314         {
315             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
316             cipher.init(Cipher.ENCRYPT_MODE, publicKey,  new SecureRandom());
317              return cipher.doFinal(input);
318         }
319          catch (Exception e)
320         {
321             e.printStackTrace();
322         }
323 
324          return  null;
325     }
326 
327      public  static  byte[] decrypt( byte[] input, Key privateKey)
328     {
329          try
330         {
331             Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
332             cipher.init(Cipher.DECRYPT_MODE, privateKey);
333              return cipher.doFinal(input);
334         }
335          catch (Exception e)
336         {
337             e.printStackTrace();
338         }
339 
340          return  null;
341     }
342 }