公钥,私钥和数字签名这样最好理解 (转载)

一、公钥加密 假设一下,我找了两个数字,一个是1,一个是2。我喜欢2这个数字,就保留起来,不告诉你们(私钥),然后我告诉大家,1是我的公钥。

我有一个文件,不能让别人看,我就用1加密了。别人找到了这个文件,但是他不知道2就是解密的私钥啊,所以他解不开,只有我可以用 数字2,就是我的私钥,来解密。这样我就可以保护数据了。

我的好朋友x用我的公钥1加密了字符a,加密后成了b,放在网上。别人偷到了这个文件,但是别人解不开,因为别人不知道2就是我的私钥, 只有我才能解密,解密后就得到a。这样,我们就可以传送加密的数据了。

二、私钥签名 如果我用私钥加密一段数据(当然只有我可以用私钥加密,因为只有我知道2是我的私钥),结果所有的人都看到我的内容了,因为他们都知 道我的公钥是1,那么这种加密有什么用处呢?

但是我的好朋友x说有人冒充我给他发信。怎么办呢?我把我要发的信,内容是c,用我的私钥2,加密,加密后的内容是d,发给x,再告诉他 解密看是不是c。他用我的公钥1解密,发现果然是c。 这个时候,他会想到,能够用我的公钥解密的数据,必然是用我的私钥加的密。只有我知道我得私钥,因此他就可以确认确实是我发的东西。 这样我们就能确认发送方身份了。这个过程叫做数字签名。当然具体的过程要稍微复杂一些。用私钥来加密数据,用途就是数字签名

总结:公钥和私钥是成对的,它们互相解密。

公钥加密,私钥解密。

私钥数字签名,公钥验证。

举例

比如有两个用户Alice和Bob,Alice想把一段明文通过双钥加密的技术发送给Bob,Bob有一对公钥和私钥,那么加密解密的过程如下:

  1. Bob将他的公开密钥传送给Alice。
  2. Alice用Bob的公开密钥加密她的消息,然后传送给Bob。
  3. Bob用他的私人密钥解密Alice的消息。

  上面的过程可以用下图表示,Alice使用Bob的公钥进行加密,Bob用自己的私钥进行解密。

例子和图出自《网络安全基础 应用与标准第二版》

RSA算法

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

[java] view plain copy print?

  1. package cn.aizichan.utils.digest;
  2. import java.security.Key;
  3. import java.security.KeyFactory;
  4. import java.security.KeyPair;
  5. import java.security.KeyPairGenerator;
  6. import java.security.PrivateKey;
  7. import java.security.PublicKey;
  8. import java.security.interfaces.RSAPrivateKey;
  9. import java.security.interfaces.RSAPublicKey;
  10. import java.security.spec.PKCS8EncodedKeySpec;
  11. import java.security.spec.X509EncodedKeySpec;
  12. import java.util.HashMap;
  13. import java.util.Map;
  14. import javax.crypto.Cipher;
  15. public class RSACoder {
  16. //非对称密钥算法
  17. public static final String KEY_ALGORITHM="RSA";
  18. /**
  19. * 密钥长度,DH算法的默认密钥长度是1024
  20. * 密钥长度必须是64的倍数,在512到65536位之间
  21. * */
  22. private static final int KEY_SIZE=512;
  23. //公钥
  24. private static final String PUBLIC_KEY="xiaoxiaorenzhe";
  25. //私钥
  26. private static final String PRIVATE_KEY="dadapangzi";
  27. /**
  28. * 初始化密钥对
  29. * @return Map 甲方密钥的Map
  30. * */
  31. public static Map<String,Object> initKey() throws Exception{
  32. //实例化密钥生成器
  33. KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
  34. //初始化密钥生成器
  35. keyPairGenerator.initialize(KEY_SIZE);
  36. //生成密钥对
  37. KeyPair keyPair=keyPairGenerator.generateKeyPair();
  38. //甲方公钥
  39. RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
  40. System.out.println("系数:"+publicKey.getModulus()+" 加密指数:"+publicKey.getPublicExponent());
  41. //甲方私钥
  42. RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
  43. System.out.println("系数:"+privateKey.getModulus()+"解密指数:"+privateKey.getPrivateExponent());
  44. //将密钥存储在map中
  45. Map<String,Object> keyMap=new HashMap<String,Object>();
  46. keyMap.put(PUBLIC_KEY, publicKey);
  47. keyMap.put(PRIVATE_KEY, privateKey);
  48. return keyMap;
  49. }
  50. /**
  51. * 私钥加密
  52. * @param data待加密数据
  53. * @param key 密钥
  54. * @return byte[] 加密数据
  55. * */
  56. public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{
  57. //取得私钥
  58. PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
  59. KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
  60. //生成私钥
  61. PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
  62. //数据加密
  63. Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
  64. cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  65. return cipher.doFinal(data);
  66. }
  67. /**
  68. * 公钥加密
  69. * @param data待加密数据
  70. * @param key 密钥
  71. * @return byte[] 加密数据
  72. * */
  73. public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
  74. //实例化密钥工厂
  75. KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
  76. //初始化公钥
  77. //密钥材料转换
  78. X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
  79. //产生公钥
  80. PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
  81. //数据加密
  82. Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
  83. cipher.init(Cipher.ENCRYPT_MODE, pubKey);
  84. return cipher.doFinal(data);
  85. }
  86. /**
  87. * 私钥解密
  88. * @param data 待解密数据
  89. * @param key 密钥
  90. * @return byte[] 解密数据
  91. * */
  92. public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
  93. //取得私钥
  94. PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
  95. KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
  96. //生成私钥
  97. PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
  98. //数据解密
  99. Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
  100. cipher.init(Cipher.DECRYPT_MODE, privateKey);
  101. return cipher.doFinal(data);
  102. }
  103. /**
  104. * 公钥解密
  105. * @param data 待解密数据
  106. * @param key 密钥
  107. * @return byte[] 解密数据
  108. * */
  109. public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{
  110. //实例化密钥工厂
  111. KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
  112. //初始化公钥
  113. //密钥材料转换
  114. X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
  115. //产生公钥
  116. PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
  117. //数据解密
  118. Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
  119. cipher.init(Cipher.DECRYPT_MODE, pubKey);
  120. return cipher.doFinal(data);
  121. }
  122. /**
  123. * 取得私钥
  124. * @param keyMap 密钥map
  125. * @return byte[] 私钥
  126. * */
  127. public static byte[] getPrivateKey(Map<String,Object> keyMap){
  128. Key key=(Key)keyMap.get(PRIVATE_KEY);
  129. return key.getEncoded();
  130. }
  131. /**
  132. * 取得公钥
  133. * @param keyMap 密钥map
  134. * @return byte[] 公钥
  135. * */
  136. public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
  137. Key key=(Key) keyMap.get(PUBLIC_KEY);
  138. return key.getEncoded();
  139. }
  140. /**
  141. * @param args
  142. * @throws Exception
  143. */
  144. public static void main(String[] args) throws Exception {
  145. //初始化密钥
  146. //生成密钥对
  147. Map<String,Object> keyMap=RSACoder.initKey();
  148. //公钥
  149. byte[] publicKey=RSACoder.getPublicKey(keyMap);
  150. //byte[] publicKey = b;
  151. //私钥
  152. byte[] privateKey=RSACoder.getPrivateKey(keyMap);
  153. System.out.println("公钥:"+Base64.encode(publicKey));
  154. System.out.println("私钥:"+Base64.encode(privateKey));
  155. System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方,开始进行加密数据的传输=============");
  156. String str="aattaggcctegthththfef/aat.mp4";
  157. System.out.println("===========甲方向乙方发送加密数据==============");
  158. System.out.println("原文:"+str);
  159. //甲方进行数据的加密
  160. byte[] code1=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
  161. System.out.println("甲方 使用乙方公钥加密后的数据:"+Base64.encode(code1));
  162. System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
  163. //乙方进行数据的解密
  164. //byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);
  165. byte[] decode1=RSACoder.decryptByPrivateKey(code1, privateKey);
  166. System.out.println("乙方解密后的数据:"+new String(decode1)+"");
  167. System.out.println("===========反向进行操作,乙方向甲方发送数据==============");
  168. str="乙方向甲方发送数据RSA算法";
  169. System.out.println("原文:"+str);
  170. //乙方使用公钥对数据进行加密
  171. byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
  172. System.out.println("===========乙方使用公钥对数据进行加密==============");
  173. System.out.println("加密后的数据:"+Base64.encode(code2));
  174. System.out.println("=============乙方将数据传送给甲方======================");
  175. System.out.println("===========甲方使用私钥对数据进行解密==============");
  176. //甲方使用私钥对数据进行解密
  177. byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);
  178. System.out.println("甲方解密后的数据:"+new String(decode2));
  179. }
  180. }

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券