java与IOS之间的RSA加解密

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

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[]，可直接用上面方法解密。。。

时间： 2024-11-06 18:28:44

java与IOS之间的RSA加解密的相关文章

java 使用pem密钥进行RSA加解密

1.使用openssl生成私钥和公钥 openssl下载地址:http://www.openssl.org/source openssl生成私钥命令:  genrsa -out rsa_private_key.pem 1024 openssl生成公钥命令:  rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem 2.此时在openssl安装目录下的bin文件夹可以看到 rsa_private_key.pem 和 rsa_publi

利用BBRSACryptor实现iOS端的RSA加解密

背景 RSA这种非对称加密被广泛的运用于网络数据的传输,但其在iOS上很难直接实现,BBRSACryptor框架通过移植openssl实现了iOS端的RSA,本文将介绍如何使用BBRSACryptor生成证书,加载公钥,以及后端如何用php读取证书,加载私钥. iOS加密 新建工程并集成BBRSACryptor 这个框架自带的demo将工程文件与框架放在了同一目录,因此在配置Header Search Paths时没有包含工程文件夹,一定注意,下面新建的工程将框架放在了工程文件夹内,因此头文件寻

【转】 Java 进行 RSA 加解密时不得不考虑到的那些事儿

[转] Java 进行 RSA 加解密时不得不考虑到的那些事儿 1. 加密的系统不要具备解密的功能,否则 RSA 可能不太合适 公钥加密,私钥解密.加密的系统和解密的系统分开部署,加密的系统不应该同时具备解密的功能,这样即使黑客攻破了加密系统,他拿到的也只是一堆无法破解的密文数据.否则的话,你就要考虑你的场景是否有必要用 RSA 了. 2. 可以通过修改生成密钥的长度来调整密文长度 生成密文的长度等于密钥长度.密钥长度越大,生成密文的长度也就越大,加密的速度也就越慢,而密文也就越难被破解掉.著名

[掌眼]iOS / Android / java / node.js 通用的 AES256 加解密算法

example.m NSString *text = @"text"; NSString *key32 = @"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; NSData *data = [text dataUsingEncoding:NSUTF8StringEncoding]; NSString *encryptedData = [[data AES256EncryptWithKey:key32] base64EncodedStringWi

java rsa加解密算法的实现

RSAUtils:RSA加解密的实现 package com.rsa.test; import java.io.ByteArrayOutputStream; import java.nio.charset.Charset; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import jav

java RSA加解密以及用途

在公司当前版本的中间件通信框架中,为了防止非授权第三方和到期客户端的连接,我们通过AES和RSA两种方式的加解密策略进行认证.对于非对称RSA加解密,因为其性能耗费较大,一般仅用于认证连接,不会用于每次报文本身的加解密(这一般使用AES/DES加密),对于较为安全的支付通道,则一般是约定定期交换加解密密钥,交换过程本身的报文则是通过RSA进行加解密的.这样就在单纯的对称加密的基础上提供了更好的保障,只要签名复杂,定期的更新足以使得破坏的成本高昂到超过破解的成本. 一般来说,公钥会发布给客户端,客

全面解决.Net与Java互通时的RSA加解密问题，使用PEM格式的密钥文件

一.缘由 RSA是一种常用的非对称加密算法.所以有时需要在不用编程语言中分别使用RSA的加密.解密.例如用Java做后台服务端,用C#开发桌面的客户端软件时.由于 .Net.Java 的RSA类库存在很多细节区别,尤其是它们支持的密钥格式不同.导致容易出现“我加密的数据对方不能解密,对方加密的数据我不能解密,但是自身是可以正常加密解密”等情况.虽然网上已经有很多文章讨论 .Net与Java互通的RSA加解密,但是存在不够全面.需要第三方dll.方案复杂 等问题.于是我仔细研究了这一课题,得到了一

【go语言】RSA加解密

关于go语言的RSA加解密的介绍,这里有一篇文章,已经介绍的很完整了. 对应的go语言的加解密代码,参考git. 因为原文跨语言是跟php,我这里要跟c语言进行交互,所以,这里贴上c语言的例子. 参考原文:http://hayageek.com/rsa-encryption-decryption-openssl-c/ #include <openssl/pem.h> #include <openssl/ssl.h> #include <openssl/rsa.h> #i

[转]PHP,Android,IOS通信之AES128加解密

转自:http://s00s10.blog.163.com/blog/static/43988552201411913011459/ android上使用: mcrypt = new MCrypt(); /* 加密*/ String encrypted = MCrypt.bytesToHex( mcrypt.encrypt("需加密的字符") ); /* 解密*/ String decrypted = new String( mcrypt.decrypt( encrypted ) );