Java对称与非对称加密解密,AES与RSA

r囧r小猫 2022-08-27 14:59 210阅读 0赞

加密技术可以分为对称与非对称两种.

对称加密,解密,即加密与解密用的是同一把秘钥,常用的对称加密技术有DES,AES等

而非对称技术,加密与解密用的是不同的秘钥,常用的非对称加密技术有RSA等

为什么要有非对称加密,解密技术呢

假设这样一种场景A要发送一段消息给B,但是又不想以明文发送,所以就需要对消息进行加密.如果采用对称加密技术,那么加密与解密用的是同一把秘钥.除非B事先就知道A的秘钥,并且保存好.这样才可以解密A发来的消息.

由于对称技术只有一把秘钥,所以秘钥的管理是一个很麻烦的问题.而非对称技术的诞生就解决了这个问题.非对称加密与解密使用的是不同的秘钥,并且秘钥对是一一对应的,即用A的私钥加密的密文只有用A的公钥才能解密.

这样的话,每个人都有两把秘钥,私钥和公钥,私钥是只有自己才知道的,不能告诉别人,而公钥是公开的,大家都可以知道.这样,当A想要发送消息给B的时候,只需要用B的公钥对消息进行加密就可以了,由于B的私钥只有B才拥有,所以A用B的公钥加密的消息只有B才能解开.而B想更换自己的秘要时也很方便,只须把公钥告诉大家就可以了.

那么,既然非对称加密如此之好,对称加密就没有存在的必要了啊,其实不然,由于非对称加密算法的开销很大,所以如果直接以非对称技术来加密发送的消息效率会很差.那么怎么办呢?解决的办法也很简单,就是把对称加密技术与非对称加密技术结合起来使用.

还是这个例子:A要发送一个消息给B.

一,A先生成一个对称秘钥,这个秘钥可以是随机生成的,

二,A用B的公钥加密第一步生成的这个对称秘钥

三,A把加密过的对称秘钥发给B

四,A用第一步生成的这个对称秘钥加密实际要发的消息

五,A把用对称秘钥加密的消息发给B

对于B

他先收到A发来的对称秘钥,这个秘钥是用B的公钥加密过的,所以B需要用自己的私钥来解密这个秘钥

然后B又收到A发来的密文,这时候用刚才解密出来的秘钥来解密密文

这样子的整个过程既保证了安全,又保证了效率.

接下来是Java实现:

我这个Java实现使用的是AES的对称加密和RSA的非对称加密(DES的对称加密实现方法和AES的是一样的,但是由于DES算法本身有缺陷,容易被破解,所以现在多用其升级版AES对称加密)

AES对称加密,解密

Java代码 ![收藏代码][icon_star.png]

1.  import java.io.IOException;
2.  import java.io.InputStream;
3.  import java.io.OutputStream;
4.  import java.security.InvalidKeyException;
5.  import java.security.Key;
6.  import java.security.NoSuchAlgorithmException;
7.  import java.security.SecureRandom;
8.  
9.  import javax.crypto.BadPaddingException;
10. import javax.crypto.Cipher;
11. import javax.crypto.IllegalBlockSizeException;
12. import javax.crypto.KeyGenerator;
13. import javax.crypto.NoSuchPaddingException;
14. import javax.crypto.ShortBufferException;
15. 
16. public class AES \{
17. 
18. private Key key;
19. 
20. /\*\*
21.  \* 生成AES对称秘钥
22.  \* @throws NoSuchAlgorithmException
23.  \*/
24. public void generateKey() throws NoSuchAlgorithmException \{
25. KeyGenerator keygen = KeyGenerator.getInstance("AES");
26. SecureRandom random = new SecureRandom();
27. keygen.init(random);
28. this.key = keygen.generateKey();
29. \}
30. 
31. 
32. /\*\*
33.  \* 加密
34.  \* @param in
35.  \* @param out
36.  \* @throws InvalidKeyException
37.  \* @throws ShortBufferException
38.  \* @throws IllegalBlockSizeException
39.  \* @throws BadPaddingException
40.  \* @throws NoSuchAlgorithmException
41.  \* @throws NoSuchPaddingException
42.  \* @throws IOException
43.  \*/
44. public void encrypt(InputStream in, OutputStream out) throws InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException, IOException \{
45. this.crypt(in, out, Cipher.ENCRYPT\_MODE);
46. \}
47. 
48. /\*\*
49.  \* 解密
50.  \* @param in
51.  \* @param out
52.  \* @throws InvalidKeyException
53.  \* @throws ShortBufferException
54.  \* @throws IllegalBlockSizeException
55.  \* @throws BadPaddingException
56.  \* @throws NoSuchAlgorithmException
57.  \* @throws NoSuchPaddingException
58.  \* @throws IOException
59.  \*/
60. public void decrypt(InputStream in, OutputStream out) throws InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException, IOException \{
61. this.crypt(in, out, Cipher.DECRYPT\_MODE);
62. \}
63. 
64. /\*\*
65.  \* 实际的加密解密过程
66.  \* @param in
67.  \* @param out
68.  \* @param mode
69.  \* @throws IOException
70.  \* @throws ShortBufferException
71.  \* @throws IllegalBlockSizeException
72.  \* @throws BadPaddingException
73.  \* @throws NoSuchAlgorithmException
74.  \* @throws NoSuchPaddingException
75.  \* @throws InvalidKeyException
76.  \*/
77. public void crypt(InputStream in, OutputStream out, int mode) throws IOException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException \{
78. Cipher cipher = Cipher.getInstance("AES");
79. cipher.init(mode, this.key);
80. 
81. int blockSize = cipher.getBlockSize();
82. int outputSize = cipher.getOutputSize(blockSize);
83. byte\[\] inBytes = new byte\[blockSize\];
84. byte\[\] outBytes = new byte\[outputSize\];
85. 
86. int inLength = 0;
87. boolean more = true;
88. while (more) \{
89. inLength = in.read(inBytes);
90. if (inLength == blockSize) \{
91. int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
92. out.write(outBytes, 0, outLength);
93. \} else \{
94. more = false;
95. \}
96. \}
97. if (inLength > 0)
98. outBytes = cipher.doFinal(inBytes, 0, inLength);
99. else
100. outBytes = cipher.doFinal();
101. out.write(outBytes);
102. out.flush();
103. \}
104. 
105. public void setKey(Key key) \{
106. this.key = key;
107. \}
108. 
109. public Key getKey() \{
110. return key;
111. \}
112. 
113. \}

RSA非对称加密,解密对称秘钥

Java代码 ![收藏代码][icon_star.png]

1.  public class RSA \{
2.  
3.  public static final int KEYSIZE = 512;
4.  
5.  private KeyPair keyPair;
6.  private Key publicKey;
7.  private Key privateKey;
8.  
9.  /\*\*
10.  \* 生成秘钥对
11.  \* @return
12.  \* @throws NoSuchAlgorithmException
13.  \*/
14. public KeyPair generateKeyPair() throws NoSuchAlgorithmException \{
15. KeyPairGenerator pairgen = KeyPairGenerator.getInstance("RSA");
16. SecureRandom random = new SecureRandom();
17. pairgen.initialize(RSA.KEYSIZE, random);
18. this.keyPair = pairgen.generateKeyPair();
19. return this.keyPair;
20. \}
21. 
22. /\*\*
23.  \* 加密秘钥
24.  \* @param key
25.  \* @return
26.  \* @throws NoSuchAlgorithmException
27.  \* @throws NoSuchPaddingException
28.  \* @throws InvalidKeyException
29.  \* @throws IllegalBlockSizeException
30.  \*/
31. public byte\[\] wrapKey(Key key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException \{
32. Cipher cipher = Cipher.getInstance("RSA");
33. cipher.init(Cipher.WRAP\_MODE, this.privateKey);
34. byte\[\] wrappedKey = cipher.wrap(key);
35. return wrappedKey;
36. \}
37. 
38. /\*\*
39.  \* 解密秘钥
40.  \* @param wrapedKeyBytes
41.  \* @return
42.  \* @throws NoSuchAlgorithmException
43.  \* @throws NoSuchPaddingException
44.  \* @throws InvalidKeyException
45.  \*/
46. public Key unwrapKey(byte\[\] wrapedKeyBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException \{
47. Cipher cipher = Cipher.getInstance("RSA");
48. cipher.init(Cipher.UNWRAP\_MODE, this.publicKey);
49. Key key = cipher.unwrap(wrapedKeyBytes, "AES", Cipher.SECRET\_KEY);
50. return key;
51. \}
52. 
53. public Key getPublicKey() \{
54. return publicKey;
55. \}
56. 
57. public void setPublicKey(Key publicKey) \{
58. this.publicKey = publicKey;
59. \}
60. 
61. public Key getPrivateKey() \{
62. return privateKey;
63. \}
64. 
65. public void setPrivateKey(Key privateKey) \{
66. this.privateKey = privateKey;
67. \}
68. 
69. \}

转自：http://redstarofsleep.iteye.com/blog/1171282

[icon_star.png]: /images/20220823/60fd19f8dfdb4fc3800071e45997eb9c.png