45号：公钥，私钥和数字签名

一、公钥加密

假设一下，我找了两个数字，一个是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有一对公钥和私钥，那么加密解密的过程如下：

Bob将他的公开密钥传送给Alice。
Alice用Bob的公开密钥加密她的消息，然后传送给Bob。
Bob用他的私人密钥解密Alice的消息。

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

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

RSA算法

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

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

原文：https://www.cnblogs.com/shenkebky/p/8461841.html

转载于:https://www.cnblogs.com/denglaomo/articles/10768309.html