java与IOS之间的RSA加解密

很简单的一个需求，ipad端给密码RSA加密，传到java后台，解密。RSA加密算法是基于一个密钥对的，分为公钥和私钥，一般情况公钥加密，私钥解密，但也可私钥加密，公钥解密。还可以验签，就是先用私钥对数据进行加密，然后对加密后的数据进行签名，得到一个签名值。然后再用公钥先验签，证明是对应私钥加密过的数据才解密。主要是为了防止来源不确定的数据。     根据上面的介绍，大家也都知道，RSA算法的关键就是密钥对，我和IOS的同事各自找了RSA的算法实现代码，都能正常根据密钥对加解密。问题是我们各自使用对方的密钥对就不能加解密成功。IOS同事也是一个新手。连RSA算法是个什么概念都没搞清楚，我也懂点IOS。所以就陪着他一起看代码，找资料。看到底什么原因引起的密钥对不能共用。后来找到下面这篇文章： Java中使用OpenSSL生成的RSA公私钥进行数据加解密
原来在用mac 系统中自带的openssl生成的密钥对文件是X509编码格式的。而我们JAVA所需的私钥文件是PKCS#8编码格式的。。所以要将在mac 系统中生成的私钥文件转下码就行了。转码方式参考上面链接。附下java代码：

1. import java.io.BufferedReader;
2. import java.io.IOException;
3. import java.io.InputStream;
4. import java.io.InputStreamReader;
5. import java.security.InvalidKeyException;
6. import java.security.KeyFactory;
7. import java.security.KeyPair;
8. import java.security.KeyPairGenerator;
9. import java.security.NoSuchAlgorithmException;
10. import java.security.SecureRandom;
11. import java.security.interfaces.RSAPrivateKey;
12. import java.security.interfaces.RSAPublicKey;
13. import java.security.spec.InvalidKeySpecException;
14. import java.security.spec.PKCS8EncodedKeySpec;
15. import java.security.spec.X509EncodedKeySpec;
16. import javax.crypto.BadPaddingException;
17. import javax.crypto.Cipher;
18. import javax.crypto.IllegalBlockSizeException;
19. import javax.crypto.NoSuchPaddingException;
20. import sun.misc.BASE64Decoder;
21. import sun.misc.BASE64Encoder;
22. public class RSAEncrypt {
23. private static final String DEFAULT_PUBLIC_KEY=
24. "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w" + "\r" +
25. "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht" + "\r" +
26. "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg" + "\r" +
27. "XIlk3gdhnzh+uoEQywIDAQAB" + "\r";
28. private static final String DEFAULT_PRIVATE_KEY=
29. "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG" + "\r" +
30. "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4" + "\r" +
31. "1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA" + "\r" +
32. "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm" + "\r" +
33. "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j" + "\r" +
34. "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo" + "\r" +
35. "MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ" + "\r" +
36. "DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM" + "\r" +
37. "6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ" + "\r" +
38. "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA" + "\r" +
39. "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX" + "\r" +
40. "TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh" + "\r" +
41. "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo" + "\r" +
42. "1NMLzI2ZfUoX" + "\r";
43. /**
44. * 私钥
45. */
46. private RSAPrivateKey privateKey;
47. /**
48. * 公钥
49. */
50. private RSAPublicKey publicKey;
51. /**
52. * 字节数据转字符串专用集合
53. */
54. private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
55. /**
56. * 获取私钥
57. * @return 当前的私钥对象
58. */
59. public RSAPrivateKey getPrivateKey() {
60. return privateKey;
61. }
62. /**
63. * 获取公钥
64. * @return 当前的公钥对象
65. */
66. public RSAPublicKey getPublicKey() {
67. return publicKey;
68. }
69. /**
70. * 随机生成密钥对
71. */
72. public void genKeyPair(){
73. KeyPairGenerator keyPairGen= null;
74. try {
75. keyPairGen= KeyPairGenerator.getInstance("RSA");
76. } catch (NoSuchAlgorithmException e) {
77. e.printStackTrace();
78. }
79. keyPairGen.initialize(1024, new SecureRandom());
80. KeyPair keyPair= keyPairGen.generateKeyPair();
81. this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
82. this.publicKey= (RSAPublicKey) keyPair.getPublic();
83. }
84. /**
85. * 从文件中输入流中加载公钥
86. * @param in 公钥输入流
87. * @throws Exception 加载公钥时产生的异常
88. */
89. public void loadPublicKey(InputStream in) throws Exception{
90. try {
91. BufferedReader br= new BufferedReader(new InputStreamReader(in));
92. String readLine= null;
93. StringBuilder sb= new StringBuilder();
94. while((readLine= br.readLine())!=null){
95. if(readLine.charAt(0)=='-'){
96. continue;
97. }else{
98. sb.append(readLine);
99. sb.append('\r');
100. }
101. }
102. loadPublicKey(sb.toString());
103. } catch (IOException e) {
104. throw new Exception("公钥数据流读取错误");
105. } catch (NullPointerException e) {
106. throw new Exception("公钥输入流为空");
107. }
108. }
109. /**
110. * 从字符串中加载公钥
111. * @param publicKeyStr 公钥数据字符串
112. * @throws Exception 加载公钥时产生的异常
113. */
114. public void loadPublicKey(String publicKeyStr) throws Exception{
115. try {
116. BASE64Decoder base64Decoder= new BASE64Decoder();
117. byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
118. KeyFactory keyFactory= KeyFactory.getInstance("RSA");
119. X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
120. this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
121. } catch (NoSuchAlgorithmException e) {
122. throw new Exception("无此算法");
123. } catch (InvalidKeySpecException e) {
124. throw new Exception("公钥非法");
125. } catch (IOException e) {
126. throw new Exception("公钥数据内容读取错误");
127. } catch (NullPointerException e) {
128. throw new Exception("公钥数据为空");
129. }
130. }
131. /**
132. * 从文件中加载私钥
133. * @param keyFileName 私钥文件名
134. * @return 是否成功
135. * @throws Exception
136. */
137. public void loadPrivateKey(InputStream in) throws Exception{
138. try {
139. BufferedReader br= new BufferedReader(new InputStreamReader(in));
140. String readLine= null;
141. StringBuilder sb= new StringBuilder();
142. while((readLine= br.readLine())!=null){
143. if(readLine.charAt(0)=='-'){
144. continue;
145. }else{
146. sb.append(readLine);
147. sb.append('\r');
148. }
149. }
150. loadPrivateKey(sb.toString());
151. } catch (IOException e) {
152. throw new Exception("私钥数据读取错误");
153. } catch (NullPointerException e) {
154. throw new Exception("私钥输入流为空");
155. }
156. }
157. public void loadPrivateKey(String privateKeyStr) throws Exception{
158. try {
159. BASE64Decoder base64Decoder= new BASE64Decoder();
160. byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
161. PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
162. KeyFactory keyFactory= KeyFactory.getInstance("RSA");
163. this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
164. } catch (NoSuchAlgorithmException e) {
165. throw new Exception("无此算法");
166. } catch (InvalidKeySpecException e) {
167. e.printStackTrace();
168. throw new Exception("私钥非法");
169. } catch (IOException e) {
170. throw new Exception("私钥数据内容读取错误");
171. } catch (NullPointerException e) {
172. throw new Exception("私钥数据为空");
173. }
174. }
175. /**
176. * 加密过程
177. * @param publicKey 公钥
178. * @param plainTextData 明文数据
179. * @return
180. * @throws Exception 加密过程中的异常信息
181. */
182. public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{
183. if(publicKey== null){
184. throw new Exception("加密公钥为空, 请设置");
185. }
186. Cipher cipher= null;
187. try {
188. cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());
189. cipher.init(Cipher.ENCRYPT_MODE, publicKey);
190. byte[] output= cipher.doFinal(plainTextData);
191. return output;
192. } catch (NoSuchAlgorithmException e) {
193. throw new Exception("无此加密算法");
194. } catch (NoSuchPaddingException e) {
195. e.printStackTrace();
196. return null;
197. }catch (InvalidKeyException e) {
198. throw new Exception("加密公钥非法,请检查");
199. } catch (IllegalBlockSizeException e) {
200. throw new Exception("明文长度非法");
201. } catch (BadPaddingException e) {
202. throw new Exception("明文数据已损坏");
203. }
204. }
205. /**
206. * 解密过程
207. * @param privateKey 私钥
208. * @param cipherData 密文数据
209. * @return 明文
210. * @throws Exception 解密过程中的异常信息
211. */
212. public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{
213. if (privateKey== null){
214. throw new Exception("解密私钥为空, 请设置");
215. }
216. Cipher cipher= null;
217. try {
218. cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());
219. cipher.init(Cipher.DECRYPT_MODE, privateKey);
220. byte[] output= cipher.doFinal(cipherData);
221. return output;
222. } catch (NoSuchAlgorithmException e) {
223. throw new Exception("无此解密算法");
224. } catch (NoSuchPaddingException e) {
225. e.printStackTrace();
226. return null;
227. }catch (InvalidKeyException e) {
228. throw new Exception("解密私钥非法,请检查");
229. } catch (IllegalBlockSizeException e) {
230. throw new Exception("密文长度非法");
231. } catch (BadPaddingException e) {
232. throw new Exception("密文数据已损坏");
233. }
234. }
235. /**
236. * 字节数据转十六进制字符串
237. * @param data 输入数据
238. * @return 十六进制内容
239. */
240. public static String byteArrayToString(byte[] data){
241. StringBuilder stringBuilder= new StringBuilder();
242. for (int i=0; i<data.length; i++){
243. //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
244. stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);
245. //取出字节的低四位 作为索引得到相应的十六进制标识符
246. stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
247. if (i<data.length-1){
248. stringBuilder.append(' ');
249. }
250. }
251. return stringBuilder.toString();
252. }
253. public static void main(String[] args){
254. RSAEncrypt rsaEncrypt= new RSAEncrypt();
255. //rsaEncrypt.genKeyPair();
256. //加载公钥
257. try {
258. rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
259. System.out.println("加载公钥成功");
260. } catch (Exception e) {
261. System.err.println(e.getMessage());
262. System.err.println("加载公钥失败");
263. }
264. //加载私钥
265. try {
266. rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
267. System.out.println("加载私钥成功");
268. } catch (Exception e) {
269. System.err.println(e.getMessage());
270. System.err.println("加载私钥失败");
271. }
272. //测试字符串
273. String encryptStr= "abc";
274. System.out.println("私钥长度："+rsaEncrypt.getPrivateKey().toString().length());
275. System.out.println("公钥长度："+rsaEncrypt.getPublicKey().toString().length());
276. try {
277. //加密
278. byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
279. //解密
280. byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
281. System.out.println("密文长度:"+ cipher.length);
282. System.out.println(RSAEncrypt.byteArrayToString(cipher));
283. System.out.println("明文长度:"+ plainText.length);
284. System.out.println(RSAEncrypt.byteArrayToString(plainText));
285. System.out.println(new String(plainText));
286. } catch (Exception e) {
287. System.err.println(e.getMessage());
288. }
289. }
290. }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class RSAEncrypt {
	private static final String DEFAULT_PUBLIC_KEY=
        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w" + "\r" +
        "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht" + "\r" +
        "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg" + "\r" +
        "XIlk3gdhnzh+uoEQywIDAQAB" + "\r";  

    private static final String DEFAULT_PRIVATE_KEY=
        "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG" + "\r" +
        "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4" + "\r" +
        "1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA" + "\r" +
        "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm" + "\r" +
        "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j" + "\r" +
        "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo" + "\r" +
        "MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ" + "\r" +
        "DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM" + "\r" +
        "6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ" + "\r" +
        "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA" + "\r" +
        "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX" + "\r" +
        "TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh" + "\r" +
        "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo" + "\r" +
        "1NMLzI2ZfUoX" + "\r";  

    /**
     * 私钥
     */
    private RSAPrivateKey privateKey;  

    /**
     * 公钥
     */
    private RSAPublicKey publicKey;  

    /**
     * 字节数据转字符串专用集合
     */
    private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};  

    /**
     * 获取私钥
     * @return 当前的私钥对象
     */
    public RSAPrivateKey getPrivateKey() {
        return privateKey;
    }  

    /**
     * 获取公钥
     * @return 当前的公钥对象
     */
    public RSAPublicKey getPublicKey() {
        return publicKey;
    }  

    /**
     * 随机生成密钥对
     */
    public void genKeyPair(){
        KeyPairGenerator keyPairGen= null;
        try {
            keyPairGen= KeyPairGenerator.getInstance("RSA");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        keyPairGen.initialize(1024, new SecureRandom());
        KeyPair keyPair= keyPairGen.generateKeyPair();
        this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
        this.publicKey= (RSAPublicKey) keyPair.getPublic();
    }  

    /**
     * 从文件中输入流中加载公钥
     * @param in 公钥输入流
     * @throws Exception 加载公钥时产生的异常
     */
    public void loadPublicKey(InputStream in) throws Exception{
        try {
            BufferedReader br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('\r');
                }
            }
            loadPublicKey(sb.toString());
        } catch (IOException e) {
            throw new Exception("公钥数据流读取错误");
        } catch (NullPointerException e) {
            throw new Exception("公钥输入流为空");
        }
    }  

    /**
     * 从字符串中加载公钥
     * @param publicKeyStr 公钥数据字符串
     * @throws Exception 加载公钥时产生的异常
     */
    public void loadPublicKey(String publicKeyStr) throws Exception{
        try {
            BASE64Decoder base64Decoder= new BASE64Decoder();
            byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");
            X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
            this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("公钥非法");
        } catch (IOException e) {
            throw new Exception("公钥数据内容读取错误");
        } catch (NullPointerException e) {
            throw new Exception("公钥数据为空");
        }
    }  

    /**
     * 从文件中加载私钥
     * @param keyFileName 私钥文件名
     * @return 是否成功
     * @throws Exception
     */
    public void loadPrivateKey(InputStream in) throws Exception{
        try {
            BufferedReader br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('\r');
                }
            }
            loadPrivateKey(sb.toString());
        } catch (IOException e) {
            throw new Exception("私钥数据读取错误");
        } catch (NullPointerException e) {
            throw new Exception("私钥输入流为空");
        }
    }  

    public void loadPrivateKey(String privateKeyStr) throws Exception{
        try {
            BASE64Decoder base64Decoder= new BASE64Decoder();
            byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
            PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");
            this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
        	e.printStackTrace();
            throw new Exception("私钥非法");
        } catch (IOException e) {
            throw new Exception("私钥数据内容读取错误");
        } catch (NullPointerException e) {
            throw new Exception("私钥数据为空");
        }
    }  

    /**
     * 加密过程
     * @param publicKey 公钥
     * @param plainTextData 明文数据
     * @return
     * @throws Exception 加密过程中的异常信息
     */
    public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{
        if(publicKey== null){
            throw new Exception("加密公钥为空, 请设置");
        }
        Cipher cipher= null;
        try {
            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] output= cipher.doFinal(plainTextData);
            return output;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此加密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        }catch (InvalidKeyException e) {
            throw new Exception("加密公钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("明文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("明文数据已损坏");
        }
    }  

    /**
     * 解密过程
     * @param privateKey 私钥
     * @param cipherData 密文数据
     * @return 明文
     * @throws Exception 解密过程中的异常信息
     */
    public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{
        if (privateKey== null){
            throw new Exception("解密私钥为空, 请设置");
        }
        Cipher cipher= null;
        try {
            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] output= cipher.doFinal(cipherData);
            return output;
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此解密算法");
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
            return null;
        }catch (InvalidKeyException e) {
            throw new Exception("解密私钥非法,请检查");
        } catch (IllegalBlockSizeException e) {
            throw new Exception("密文长度非法");
        } catch (BadPaddingException e) {
            throw new Exception("密文数据已损坏");
        }
    }  

    /**
     * 字节数据转十六进制字符串
     * @param data 输入数据
     * @return 十六进制内容
     */
    public static String byteArrayToString(byte[] data){
        StringBuilder stringBuilder= new StringBuilder();
        for (int i=0; i<data.length; i++){
            //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);
            //取出字节的低四位 作为索引得到相应的十六进制标识符
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
            if (i<data.length-1){
                stringBuilder.append(' ');
            }
        }
        return stringBuilder.toString();
    }  

    public static void main(String[] args){
        RSAEncrypt rsaEncrypt= new RSAEncrypt();
        //rsaEncrypt.genKeyPair();  

        //加载公钥
        try {
            rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
            System.out.println("加载公钥成功");
        } catch (Exception e) {
            System.err.println(e.getMessage());
            System.err.println("加载公钥失败");
        }  

        //加载私钥
        try {
            rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
            System.out.println("加载私钥成功");
        } catch (Exception e) {
            System.err.println(e.getMessage());
            System.err.println("加载私钥失败");
        }  

        //测试字符串
        String encryptStr= "abc";
        System.out.println("私钥长度："+rsaEncrypt.getPrivateKey().toString().length());
        System.out.println("公钥长度："+rsaEncrypt.getPublicKey().toString().length());
        try {
            //加密
            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());  

            //解密
            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);  

            System.out.println("密文长度:"+ cipher.length);
            System.out.println(RSAEncrypt.byteArrayToString(cipher));
            System.out.println("明文长度:"+ plainText.length);
            System.out.println(RSAEncrypt.byteArrayToString(plainText));
            System.out.println(new String(plainText));
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}

提供两种方式加载密钥对，可通过字符串或者文件流，文件是指生成的.pem文件才可以哦。 另外附一份IOS中加密方法，不过这里要求的文件是der。 http://blog.yorkgu.me/2011/10/27/rsa-in-ios-using-publick-key-generated-by-openssl/ IOS中加密后返回的NSdata对象，可以对NSdata对象进行base64编码转换成字符串，然后java用BASE64Decoder解码之后，就转换成了byte[]，可直接用上面方法解密。。。