Java中使用OpenSSL生成的RSA公私钥进行数据加解密

RSA是什么：RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够 抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。目前该加密方式广泛用于网上银行、数字签名等场合。RSA算法基于一个十分简单的 数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

OpenSSL是什 么：众多的密码算法、公钥基础设施标准以及SSL协议，或许这些有趣的功能会让你产生实现所有这些算法和标准的想法。果真如此，在对你表示敬佩的同时，还 是忍不住提醒你：这是一个令人望而生畏的过程。这个工作不再是简单的读懂几本密码学专著和协议文档那么简单，而是要理解所有这些算法、标准和协议文档的每 一个细节，并用你可能很熟悉的C语言字符一个一个去实现这些定义和过程。我们不知道你将需要多少时间来完成这项有趣而可怕的工作，但肯定不是一年两年的问 题。OpenSSL就是由Eric A. Young和Tim J. Hudson两位绝世大好人自1995年就开始编写的集合众多安全算法的算法集合。通过命令或者开发库，我们可以轻松实现标准的公开算法应用。

我的一个假设应用背景：

随 着移动互联网的普及，为移动设备开发的应用也层出不穷。这些应用往往伴随着用户注册与密码验证的功能。”网络传输“、”应用程序日志访问“中的安全性都存 在着隐患。密码作为用户的敏感数据，特别需要开发者在应用上线之前做好安全防范。处理不当，可能会造成诸如商业竞争对手的恶意攻击、第三方合作商的诉讼等 问题。

RSA算法虽然有这么多好处，但是在网上找不到一个完整的例子来说明如何操作。下面我就来介绍一下：

一、使用OpenSSL来生成私钥和公钥

我使用的是Linux系统，已经安装了OpenSSL软件包，此时请验证你的机器上已经安装了OpenSSL，运行命令应当出现如下信息：

[plain] view plaincopy

  1. [[email protected] ~]# openssl version -a
  2. OpenSSL 1.0.0-fips 29 Mar 2010
  3. built on: Wed Jan 25 02:17:15 GMT 2012
  4. platform: linux-x86_64
  5. options:  bn(64,64) md2(int) rc4(16x,int) des(idx,cisc,16,int) blowfish(idx)
  6. compiler: gcc -fPIC -DOPENSSL_PIC -DZLIB -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -DKRB5_MIT -m64 -DL_ENDIAN -DTERMIO -Wall -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m64 -mtune=generic -Wa,--noexecstack -DMD32_REG_T=int -DOPENSSL_IA32_SSE2 -DOPENSSL_BN_ASM_MONT -DSHA1_ASM -DSHA256_ASM -DSHA512_ASM -DMD5_ASM -DAES_ASM -DWHIRLPOOL_ASM
  7. OPENSSLDIR: "/etc/pki/tls"
  8. engines:  aesni dynamic

先来生成私钥：

[plain] view plaincopy

  1. [[email protected] ~]# openssl genrsa -out rsa_private_key.pem 1024
  2. Generating RSA private key, 1024 bit long modulus
  3. .......................++++++
  4. ..++++++
  5. e is 65537 (0x10001)

这条命令让openssl随机生成了一份私钥，加密长度是1024位。加密长度是指理论上最大允许”被加密的信息“长度的限制，也就是明文的长度限制。随着这个参数的增大（比方说2048），允许的明文长度也会增加，但同时也会造成计算复杂度的极速增长。一般推荐的长度就是1024位（128字节）。

我们来看一下私钥的内容：

[plain] view plaincopy

  1. [[email protected] ~]# cat rsa_private_key.pem
  2. -----BEGIN RSA PRIVATE KEY-----
  3. MIICWwIBAAKBgQChDzcjw/rWgFwnxunbKp7/4e8w/UmXx2jk6qEEn69t6N2R1i/L
  4. mcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRhtVx1uOH/2U378fscEESEG8XDq
  5. ll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNgXIlk3gdhnzh+uoEQywIDAQAB
  6. AoGAaeKk76CSsp7k90mwyWP18GhLZru+vEhfT9BpV67cGLg1owFbntFYQSPVsTFm
  7. U2lWn5HD/IcV+EGaj4fOLXdM43Kt4wyznoABSZCKKxs6uRciu8nQaFNUy4xVeOfX
  8. PHU2TE7vi4LDkw9df1fya+DScSLnaDAUN3OHB5jqGL+Ls5ECQQDUfuxXN3uqGYKk
  9. znrKj0j6pY27HRfROMeHgxbjnnApCQ71SzjqAM77R3wIlKfh935OIV0aQC4jQRB4
  10. iHYSLl9lAkEAwgh4jxxXeIAufMsgjOi3qpJqGvumKX0W96McpCwV3Fsew7W1/msi
  11. suTkJp5BBvjFvFwfMAHYlJdP7W+nEBWkbwJAYbz/eB5NAzA4pxVR5VmCd8cuKaJ4
  12. EgPLwsjI/mkhrb484xZ2VyuICIwYwNmfXpA3yDgQWsKqdgy3Rrl9lV8/AQJAcjLi
  13. IfigUr++nJxA8C4Xy0CZSoBJ76k710wdE1MPGr5WgQF1t+P+bCPjVAdYZm4Mkyv0
  14. /yBXBD16QVixjvnt6QJABli6Zx9GYRWnu6AKpDAHd8QjWOnnNfNLQHue4WepEvkm
  15. CysG+IBs2GgsXNtrzLWJLFx7VHmpqNTTC8yNmX1KFw==
  16. -----END RSA PRIVATE KEY-----

内容都是标准的ASCII字符，开头一行和结尾一行有明显的标记，真正的私钥数据是中间的不规则字符。

2015 年3月24日补充：密钥文件最终将数据通过Base64编码进行存储。可以看到上述密钥文件内容每一行的长度都很规律。这是由于RFC2045中规 定：The encoded output stream must be represented in lines of no more than 76 characters each。也就是说Base64编码的数据每行最多不超过76字符，对于超长数据需要按行分割。

接下来根据私钥生成公钥：

[plain] view plaincopy

  1. [[email protected] ~]# openssl rsa -in rsa_private_key.pem -out rsa_public_key.pem -pubout
  2. writing RSA key

再来看一下公钥的内容：

[plain] view plaincopy

  1. [[email protected] ~]# cat rsa_public_ley.pem
  2. -----BEGIN PUBLIC KEY-----
  3. MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w
  4. /UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht
  5. Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg
  6. XIlk3gdhnzh+uoEQywIDAQAB
  7. -----END PUBLIC KEY-----

这时候的私钥还不能直接被使用，需要进行PKCS#8编码：

[plain] view plaincopy

  1. [[email protected] ~]# openssl pkcs8 -topk8 -in rsa_private_key.pem -out pkcs8_rsa_private_key.pem -nocrypt

命令中指明了输入私钥文件为rsa_private_key.pem，输出私钥文件为pkcs8_rsa_private_key.pem，不采用任何二次加密（-nocrypt）

再来看一下，编码后的私钥文件是不是和之前的私钥文件不同了：

[plain] view plaincopy

  1. [[email protected] ~]# cat pkcs8_rsa_private_key.pem
  2. -----BEGIN PRIVATE KEY-----
  3. MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG
  4. 6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4
  5. 1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA
  6. ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm
  7. u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j
  8. DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo
  9. MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ
  10. DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM
  11. 6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ
  12. FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA
  13. 2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX
  14. TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh
  15. Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo
  16. 1NMLzI2ZfUoX
  17. -----END PRIVATE KEY-----

至此，可用的密钥对已经生成好了，私钥使用pkcs8_rsa_private_key.pem，公钥采用rsa_public_key.pem。

2014年5月20日补充：最近又遇到RSA加密的需求了，而且对方要求只能使用第一步生成的未经过PKCS#8编码的私钥文件。后来查看相关文献得知第一步生成的私钥文件编码是PKCS#1格式，这种格式Java其实是支持的，只不过多写两行代码而已：

[java] view plaincopy

  1. RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure((ASN1Sequence) ASN1Sequence.fromByteArray(priKeyData));
  2. RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
  3. KeyFactory keyFactory= KeyFactory.getInstance("RSA");
  4. PrivateKey priKey= keyFactory.generatePrivate(rsaPrivKeySpec);

首先将PKCS#1的私钥文件读取出来（注意去掉减号开头的注释内容），然后使用Base64解码读出的字符串，便得到priKeyData，也就是第一行代码中的参数。最后一行得到了私钥。接下来的用法就没什么区别了。

参考文献：https://community.oracle.com/thread/1529240?start=0&tstart=0

二、编写Java代码实际测试

2012 年2月23日补充：在标准JDK中只是规定了JCE(JCE (Java Cryptography Extension) 是一组包，它们提供用于加密、密钥生成和协商以及 Message Authentication Code(MAC)算法的框架和实现。它提供对对称、不对称、块和流密码的加密支持，它还支持安全流和密封的对象。)接口，但是内部实现需要自己或者第三 方提供。因此我们这里使用bouncycastle的开源的JCE实现包，下载地址：http://bouncycastle.org /latest_releases.html，我使用的是bcprov-jdk16-146.jar，这是在JDK1.6环境下使用的。如果需要其他 JDK版本下的实现，可以在之前的下载页面中找到对应版本。

下面来看一下我实现的代码：

[java] view plaincopy

  1. package net.csdn.blog.chaijunkun;
  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.InputStreamReader;
  6. import java.security.InvalidKeyException;
  7. import java.security.KeyFactory;
  8. import java.security.KeyPair;
  9. import java.security.KeyPairGenerator;
  10. import java.security.NoSuchAlgorithmException;
  11. import java.security.SecureRandom;
  12. import java.security.interfaces.RSAPrivateKey;
  13. import java.security.interfaces.RSAPublicKey;
  14. import java.security.spec.InvalidKeySpecException;
  15. import java.security.spec.PKCS8EncodedKeySpec;
  16. import java.security.spec.X509EncodedKeySpec;
  17. import javax.crypto.BadPaddingException;
  18. import javax.crypto.Cipher;
  19. import javax.crypto.IllegalBlockSizeException;
  20. import javax.crypto.NoSuchPaddingException;
  21. import org.bouncycastle.jce.provider.BouncyCastleProvider;
  22. import sun.misc.BASE64Decoder;
  23. public class RSAEncrypt {
  24. private static final String DEFAULT_PUBLIC_KEY=
  25. "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w" + "\r" +
  26. "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht" + "\r" +
  27. "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg" + "\r" +
  28. "XIlk3gdhnzh+uoEQywIDAQAB" + "\r";
  29. private static final String DEFAULT_PRIVATE_KEY=
  30. "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG" + "\r" +
  31. "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4" + "\r" +
  32. "1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA" + "\r" +
  33. "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm" + "\r" +
  34. "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j" + "\r" +
  35. "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo" + "\r" +
  36. "MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ" + "\r" +
  37. "DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM" + "\r" +
  38. "6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ" + "\r" +
  39. "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA" + "\r" +
  40. "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX" + "\r" +
  41. "TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh" + "\r" +
  42. "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo" + "\r" +
  43. "1NMLzI2ZfUoX" + "\r";
  44. /**
  45. * 私钥
  46. */
  47. private RSAPrivateKey privateKey;
  48. /**
  49. * 公钥
  50. */
  51. private RSAPublicKey publicKey;
  52. /**
  53. * 字节数据转字符串专用集合
  54. */
  55. private static final char[] HEX_CHAR= {‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘, ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘};
  56. /**
  57. * 获取私钥
  58. * @return 当前的私钥对象
  59. */
  60. public RSAPrivateKey getPrivateKey() {
  61. return privateKey;
  62. }
  63. /**
  64. * 获取公钥
  65. * @return 当前的公钥对象
  66. */
  67. public RSAPublicKey getPublicKey() {
  68. return publicKey;
  69. }
  70. /**
  71. * 随机生成密钥对
  72. */
  73. public void genKeyPair(){
  74. KeyPairGenerator keyPairGen= null;
  75. try {
  76. keyPairGen= KeyPairGenerator.getInstance("RSA");
  77. } catch (NoSuchAlgorithmException e) {
  78. e.printStackTrace();
  79. }
  80. keyPairGen.initialize(1024, new SecureRandom());
  81. KeyPair keyPair= keyPairGen.generateKeyPair();
  82. this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
  83. this.publicKey= (RSAPublicKey) keyPair.getPublic();
  84. }
  85. /**
  86. * 从文件中输入流中加载公钥
  87. * @param in 公钥输入流
  88. * @throws Exception 加载公钥时产生的异常
  89. */
  90. public void loadPublicKey(InputStream in) throws Exception{
  91. try {
  92. BufferedReader br= new BufferedReader(new InputStreamReader(in));
  93. String readLine= null;
  94. StringBuilder sb= new StringBuilder();
  95. while((readLine= br.readLine())!=null){
  96. if(readLine.charAt(0)==‘-‘){
  97. continue;
  98. }else{
  99. sb.append(readLine);
  100. sb.append(‘\r‘);
  101. }
  102. }
  103. loadPublicKey(sb.toString());
  104. } catch (IOException e) {
  105. throw new Exception("公钥数据流读取错误");
  106. } catch (NullPointerException e) {
  107. throw new Exception("公钥输入流为空");
  108. }
  109. }
  110. /**
  111. * 从字符串中加载公钥
  112. * @param publicKeyStr 公钥数据字符串
  113. * @throws Exception 加载公钥时产生的异常
  114. */
  115. public void loadPublicKey(String publicKeyStr) throws Exception{
  116. try {
  117. BASE64Decoder base64Decoder= new BASE64Decoder();
  118. byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
  119. KeyFactory keyFactory= KeyFactory.getInstance("RSA");
  120. X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
  121. this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
  122. } catch (NoSuchAlgorithmException e) {
  123. throw new Exception("无此算法");
  124. } catch (InvalidKeySpecException e) {
  125. throw new Exception("公钥非法");
  126. } catch (IOException e) {
  127. throw new Exception("公钥数据内容读取错误");
  128. } catch (NullPointerException e) {
  129. throw new Exception("公钥数据为空");
  130. }
  131. }
  132. /**
  133. * 从文件中加载私钥
  134. * @param keyFileName 私钥文件名
  135. * @return 是否成功
  136. * @throws Exception
  137. */
  138. public void loadPrivateKey(InputStream in) throws Exception{
  139. try {
  140. BufferedReader br= new BufferedReader(new InputStreamReader(in));
  141. String readLine= null;
  142. StringBuilder sb= new StringBuilder();
  143. while((readLine= br.readLine())!=null){
  144. if(readLine.charAt(0)==‘-‘){
  145. continue;
  146. }else{
  147. sb.append(readLine);
  148. sb.append(‘\r‘);
  149. }
  150. }
  151. loadPrivateKey(sb.toString());
  152. } catch (IOException e) {
  153. throw new Exception("私钥数据读取错误");
  154. } catch (NullPointerException e) {
  155. throw new Exception("私钥输入流为空");
  156. }
  157. }
  158. public void loadPrivateKey(String privateKeyStr) throws Exception{
  159. try {
  160. BASE64Decoder base64Decoder= new BASE64Decoder();
  161. byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
  162. PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
  163. KeyFactory keyFactory= KeyFactory.getInstance("RSA");
  164. this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
  165. } catch (NoSuchAlgorithmException e) {
  166. throw new Exception("无此算法");
  167. } catch (InvalidKeySpecException e) {
  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= "Test String chaijunkun";
  274. try {
  275. //加密
  276. byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
  277. //解密
  278. byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
  279. System.out.println("密文长度:"+ cipher.length);
  280. System.out.println(RSAEncrypt.byteArrayToString(cipher));
  281. System.out.println("明文长度:"+ plainText.length);
  282. System.out.println(RSAEncrypt.byteArrayToString(plainText));
  283. System.out.println(new String(plainText));
  284. } catch (Exception e) {
  285. System.err.println(e.getMessage());
  286. }
  287. }
  288. }

代码中我提供了两种加载公钥和私钥的方式。

按流来读取：适合在android应用中按ID索引资源得到InputStream的方式；

按字符串来读取：就像代码中展示的那样，将密钥内容按行存储到静态常量中，按String类型导入密钥。

运行上面的代码，会显示如下信息：

[plain] view plaincopy

  1. 加载公钥成功
  2. 加载私钥成功
  3. 密文长度:128
  4. 35 b4 6f 49 69 ae a3 85 a2 a5 0d 45 75 00 23 23 e6 70 69 b4 59 ae 72 6f 6d d3 43 e1 d3 44 85 eb 04 57 2c 46 3e 70 09 4d e6 4c 83 50 c7 56 75 80 c7 e1 31 64 57 c8 e3 46 a7 ce 57 31 ac cd 21 89 89 8f c1 24 c1 22 0c cb 70 6a 0d fa c9 38 80 ba 2e e1 29 02 ed 45 9e 88 e9 23 09 87 af ad ab ac cb 61 03 3c a1 81 56 a5 de c4 79 aa 3e 48 ee 30 3d bc 5b 47 50 75 9f fd 22 87 9e de b1 f4 e8 b2
  5. 明文长度:22
  6. 54 65 73 74 20 53 74 72 69 6e 67 20 63 68 61 69 6a 75 6e 6b 75 6e
  7. Test String chaijunkun

在main函数中我注释掉了”rsaEncrypt.genKeyPair()“，这个方法是用来随机生成密钥对的（只生成、使用，不存储）。当不使用文件密钥时，可以将载入密钥的代码注释，启用本方法，也可以跑通代码。

加载公钥与加载私钥的不同点在于公钥加载时使用的是X509EncodedKeySpec（X509编码的Key指令），私钥加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。

2012 年2月22日补充：在android软件开发的过程中，发现上述代码不能正常工作，主要原因在于sun.misc.BASE64Decoder类在 android开发包中不存在。因此需要特别在网上寻找rt.jar的源代码，至于JDK的src.zip中的源代码，这个只是JDK中的部分源代码，上 述的几个类的代码都没有。经过寻找并添加，上述代码在android应用中能够很好地工作。其中就包含这个类的对应代码。另外此类还依赖于 CEFormatException、CEStreamExhausted、CharacterDecoder和CharacterEncoder类和异 常定义。

2012 年2月23日补充：起初，我写这篇文章是想不依赖于任何第三方包来实现RSA的加密与解密，然而后续遇到了问题。由于在加密方法encrypt和解密方法 decrypt中都要建立一个Cipher对象，这个对象只能通过getInstance来获取实例。它有两种：第一个是只指定算法，不指定提供者 Provider的；第二个是两个都要指定的。起初没有指定，代码依然能够跑通，但是你会发现，每次加密的结果都不一样。后来分析才知道Cipher对象 使用的公私钥是内部自己随机生成的，不是代码中指定的公私钥。奇怪的是，这种不指定Provider的代码能够在android应用中跑通，而且每次加密 的结果都相同。我想，android的SDK中除了系统的一些开发函数外，自己也实现了JDK的功能，可能在它自己的JDK中已经提供了相应的 Provider，才使得每次加密结果相同。当我像网上的示例代码那样加入了bouncycastle的Provider后，果然每次加密的结果都相同了。

时间： 2024-12-18 09:57:47

Java中使用OpenSSL生成的RSA公私钥进行数据加解密的相关文章

Java中使用OpenSSL生成的RSA公私钥

RSA是什么:RSA公钥加密算法是1977年由Ron Rivest.Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的.RSA取名来自开发他们三者的名字.RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准.目前该加密方式广泛用于网上银行.数字签名等场合.RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥. OpenSSL是什么:众

java生成RSA公私钥字符串，简单易懂

java生成RSA公私钥字符串,简单易懂 解决方法: 1.下载bcprov-jdk16-140.jar包,参考:http://www.yayihouse.com/yayishuwu/chapter/1537 2.java代码 KeyPairGenerator keyPairGenerator = KeyPairGenerator .getInstance("RSA"); keyPairGenerator.initialize(2048); KeyPair keyPair = keyPa

ios下使用rsa算法与php进行加解密通讯

首先了解一下几个相关概念,以方便后面遇到的问题的解决: RSA算法:1977年由Ron Rivest.Adi Shamirh和LenAdleman发明的,RSA就是取自他们三个人的名字.算法基于一个数论:将两个大素数相乘非常容易,但要对这个乘积的结果进行因式分解却非常困难,因此可以把乘积公开作为公钥.该算法能够抵抗目前已知的所有密码攻击.RSA算法是一种非对称算法,算法需要一对密钥,使用其中一个加密,需要使用另外一个才能解密.我们在进行RSA加密通讯时,就把公钥放在客户端,私钥留在服务器. DE

Python rsa公私钥生成 rsa公钥加密(分段加密)私钥加签实战

一般现在的SAAS服务提供现在的sdk或api对接服务都涉及到一个身份验证和数据加密的问题.一般现在普遍的做法就是配置使用非对称加密的方式来解决这个问题,你持有SAAS公司的公钥,SAAS公司持有你的公钥,你们就可以进行加密和签名的验证了. 先来看下两种在linux或者mac下面生成key pair的方法: 使用openssl 生成一把2048bit长度的钥匙对,首先我们生成一把.pem格式的私钥: openssl genrsa -out private_key.pem 2048 然后通过这把私

用openssl生成SSL使用的私钥和证书，并自己做CA签名（转）

本 文记叙的是一次基于SSL的socket通讯程序开发中,有关证书,签名,身份验证相关的步骤. 我们的场景下,socket服务端是java语言编写的,客户端是c语言.使用了一个叫做matrixssl的c语言库.自己做CA签名,不等同于“自签 名”. 自签名的情况,RSA的公钥私钥只有一对,用私钥对公钥证书做签名.而我们的场景是,自己做CA,有一个CA的公钥私钥对. 而socket的服务端也有一个公钥私钥对. 用CA的私钥对socket服务端的公钥证书做签名. openssl genrsa -ou

利用Java.util.UUID来生成唯一ID(用来做数据库主键好用)

UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字,它保证对在同一时空中的所有机器都是唯一的.按照开放软件基金会(OSF)制定的标准计算,用到了以太网卡地址.纳秒级时间.芯片ID码和许多可能的数字.由以下几部分的组合:当前日期和时间(UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,其余相同),时钟序列,全局唯一的IEEE机器识别号(如果有网卡,从网卡获得,没有网卡以其他方式获得

RSA 公私钥 互换问题

关于 RSA,我的理解是: 按定义的话,公私钥是可以互换的 问题是常见的实现里面,保存“私钥”的那个数据结构或者文件,里面除了私钥所必需的那一对数之外,还有额外的信息(足以算出公钥来),所以绝对不能把这个“私钥”数据给其他人…… n=pq φ(n)=(p-1)(q-1) m^φ(n) ≡ 1 mod n 令 ed ≡ 1 mod φ(n) cipher=m^e mod n plain = cipher ^ d mod n ≡ m^ed mod n = m 理论上e与d是可以互换的,但是一般公钥指

用openssl生成SSL使用的私钥和证书，并自己做CA签名

自签名的情况,RSA的公钥私钥只有一对,用私钥对公钥证书做签名.而我们的场景是,自己做CA,有一个CA的公钥私钥对. 而socket的服务端也有一个公钥私钥对. 用CA的私钥对socket服务端的公钥证书做签名.1.创建key,没有用des3加密 openssl genrsa -out ca.key 1024 2.需要在提示之下输入许多信息,包括国家代码,省份,城市,公司机构名等 openssl req -new -x509 -days 36500 -key ca.key -out ca.crt

在JAVA中使用JSONObject生成json

JSON是一种轻量级的数据交换格式,在现在的web开发中,是非常常见的.在没有方便的工具之前,我们或许会使用拼字符串的形式来生成json数组,今天我们使用一个json-lib.jar包来为我们实现生成json的功能. 所必须的包有: commons-httpclient-3.1.jar commons-lang-2.4.jar commons-logging-1.1.1.jar json-lib-2.4-jdk15.jar ezmorph-1.0.6.jar commons-collection