第十五篇：JAVA加密解密之对称加密

来源：互联网发布：澳洲程序员工资水平编辑：程序博客网时间：2024/05/18 03:08

对称加密简介

需要对加密和解密使用相同密钥的加密算法。由于其速度快，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。
所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。算法是一组规则，规定如何进行加密和解密。
因此加密的安全性不仅取决于加密算法本身，密钥管理的安全性更是重要。因为加密和解密都使用同一个密钥，如何把密钥安全地传递到解密者手上就成了必须要解决的问题。
对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。
对称加密算法的缺点是在数据传送前，发送方和接收方必须商定好秘钥，然后使双方都能保存好秘钥。其次如果一方的秘钥被泄露，那么加密信息也就不安全了。另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的唯一秘钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。

甲方甲方乙方乙方甲乙双方约定密钥使用约定密钥对数据进行加密发送数据使用约定密钥对接收到的数据进行解密

DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1976年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），随后在国际上广泛流传开来。

DESede是由DES对称加密算法改进后的一种对称加密算法。使用 168 位的密钥对资料进行三次加密的一种机制；它通常（但非始终）提供极其强大的安全性。如果三个 56 位的子元素都相同，则三重 DES 向后兼容 DES。

AES，高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。

Blowfish算法是一个64位分组及可变密钥长度的对称密钥分组密码算法，可用来加密64比特长度的字符串。32位处理器诞生后，Blowfish算法因其在加密速度上超越了DES而引起人们的关注。Blowfish算法具有加密速度快、紧凑、密钥长度可变、可免费使用等特点，已被广泛使用于众多加密软件。

RC2是由著名密码学家Ron Rivest设计的一种传统对称分组加密算法，它可作为DES算法的建议替代算法。它的输入和输出都是64比特。密钥的长度是从1字节到128字节可变，但目前的实现是8字节（1998年）。

RC4加密算法是大名鼎鼎的RSA三人组中的头号人物Ronald Rivest在1987年设计的密钥长度可变的流加密算法簇。之所以称其为簇，是由于其核心部分的S-box长度可为任意，但一般为256字节。该算法的速度可以达到DES加密的10倍左右，且具有很高级别的非线性。RC4起初是用于保护商业机密的。但是在1994年9月，它的算法被发布在互联网上，也就不再有什么商业机密了。RC4也被叫做ARC4（Alleged RC4——所谓的RC4），因为RSA从来就没有正式发布过这个算法。

对称加密算法实现

package com.jianggujin.codec;import java.security.Key;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;/** * 对称加密 *  * @author jianggujin * */public class HQSymmetrical{   private static HQSymmetrical symmetrical = new HQSymmetrical();   public static HQSymmetrical getInstance()   {      return symmetrical;   }   private HQSymmetrical()   {   }   /**    * 对称算法    *     * @author jianggujin    *    */   public static enum HQSymmetricalAlgorithm   {      DES("DES"), DESede("DESede"), ARCFOUR("ARCFOUR"), AES("AES"), Blowfish("Blowfish"), RC2("RC2"), RC4("RC4");      private String name;      private HQSymmetricalAlgorithm(String name)      {         this.name = name;      }      public String getName()      {         return this.name;      }   }   public byte[] encrypt(String algorithm, byte[] data, byte[] key) throws Exception   {      return operate(Cipher.ENCRYPT_MODE, algorithm, data, key);   }   public byte[] encrypt(HQSymmetricalAlgorithm algorithm, byte[] data, byte[] key) throws Exception   {      return encrypt(algorithm.toString(), data, key);   }   public byte[] decrypt(String algorithm, byte[] data, byte[] key) throws Exception   {      return operate(Cipher.DECRYPT_MODE, algorithm, data, key);   }   public byte[] decrypt(HQSymmetricalAlgorithm algorithm, byte[] data, byte[] key) throws Exception   {      return decrypt(algorithm.toString(), data, key);   }   private static Key toKey(String algorithm, byte[] key) throws Exception   {      // if ("DES".equals(algorithm))      // {      // DESKeySpec dks = new DESKeySpec(key);      // SecretKeyFactory keyFactory =      // SecretKeyFactory.getInstance(algorithm);      // SecretKey secretKey = keyFactory.generateSecret(dks);      // return secretKey;      // }      return new SecretKeySpec(key, algorithm);   }   public byte[] initKey(HQSymmetricalAlgorithm algorithm) throws Exception   {      return initKey(algorithm.getName());   }   public byte[] initKey(String algorithm) throws Exception   {      KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);      SecretKey secretKey = keyGenerator.generateKey();      return secretKey.getEncoded();   }   private byte[] operate(int mode, String algorithm, byte[] data, byte[] key) throws Exception   {      Key k = toKey(algorithm, key);      Cipher cipher = Cipher.getInstance(algorithm);      cipher.init(mode, k);      return cipher.doFinal(data);   }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

编写测试代码：

import org.junit.Test;import com.jianggujin.codec.HQBase64;import com.jianggujin.codec.HQSymmetrical;import com.jianggujin.codec.HQSymmetrical.HQSymmetricalAlgorithm;public class SymmetricalTest{   HQSymmetrical symmetrical = HQSymmetrical.getInstance();   HQBase64 base64 = HQBase64.getInstance();   @Test   public void encode() throws Exception   {      byte[] data = "jianggujin".getBytes();      HQSymmetricalAlgorithm[] algorithms = HQSymmetricalAlgorithm.values();      for (HQSymmetricalAlgorithm algorithm : algorithms)      {         byte[] key = symmetrical.initKey(algorithm);         byte[] result = symmetrical.encrypt(algorithm, data, key);         System.err.println(algorithm + ":" + base64.encodeToString(result) + ":"               + new String(symmetrical.decrypt(algorithm, result, key)));      }   }}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果如下：
DES:QGZ18EJGlQt1puJ/BfmtvQ==:jianggujin
DESede:nGgfnYjTpOgU6IaYAeJRqQ==:jianggujin
ARCFOUR:0+6WStb7a1Yxfg==:jianggujin
AES:TQSLXLSvy/BJNTGD8oR7Fw==:jianggujin
Blowfish:OTE1KVNaqGRq2jRIO/jRBQ==:jianggujin
RC2:iiUUjmwzxBpKYuaL9nClzA==:jianggujin
RC4:UUnQARSy5E4mMQ==:jianggujin

阅读全文

0 0