2020-05-22-数据加密

网络数据加密

互联网，将全球不同的计算机等电子设备连接起来，使具备互相通信的条件，但是通信信息有些事隐私，有些通信不能被其他人知道。互联网私人生活交流信息不被恶意者随意窃取，也应该是社会秩序正常稳定的表现，平时的通信不过如此，涉及到商业信息，数据保密更显得格外重要。加密算法是保持通信信息不泄漏的一种技术，可用手段。”

前言

网络数据加密是必须做的事

安全正确必要性

互联网通信通过电缆或者无线设备，信息是可以被中间人收到记录的，所以要考虑很多风险因素，信息必须被加密处理只是其中之一的考虑

信息安全

明文可能被第三方劫持查看。

就像写信一样，A写信给B，在信件到达B手上之前，信件在途中可能被别人拆开看过然后再封装原样，使AB都不能发觉信息已经被第三个人看了。

信息正确

传输信息可能被修改

同样A给B写信，在途中信件被人劫持，如果信件途中被别人打开，替换里面的信息内容，B收到后的信息很可能是错误的。

网络也是一样，网络通信必须通过有线或者无线设备传输，所以一定是可以劫持的，明文通信没有隐私可言，极不安全，所以加密算法通常需要做的事

概念

参考文章

https://www.cnblogs.com/hulianwangjiagoushi/p/10671771.html

首先加密是因为存在网路信息传输，所以加密的使用过程分三步

举例 A计算机通过网络传输信息给B计算机，中间使用加密算法过程如下

A (明文 —>加密—>密文) -----------网络（密文）-----------> B（密文 —>解密—>明文）

1
st=>start: 明文
2
op1=>operation: A端加密
3
op2=>operation: 加密密文网络传输
4
cond=>condition: 签名确认 是否为A端发送的加密数据?
5
op3=>operation: B端解密
6
op4=>operation: 丢弃（被篡改）信息
7
e=>end: 明文
8
st->op1->op2->cond
9
op3->e
10
cond(yes)->op3->e
11
cond(no)->op4
12

13
#cond=>condition: Yes or No?
14
#cond(yes)->e
15
#cond(no)->op

密钥

用于加密的根据，明文加密成密文的凭据，根据密钥有规则的加密，也只有根据密钥才能有规则的解密，应此通信中加密的密钥保管也很重要（不能被泄露）

明文

明文指两者通信的原文，能看懂的。

加密

将明文通过某种方式加密变成密文

密文

将明文加密后的信息，并且除了密钥，不能用其他方式将其解密成原文信息

传输

密文的传输（不怕别人看到密文，密文看不到真实信息，第三方不能获取有效信息）

解密

将密文还原成明文（接收者能看到明文）

签名

保证双方的信息真实没被修改的技术

A与B之间要有一种签名存在，在通信的时候，收到信息，通过签名要能鉴别信息是否被第三方修改或者信息是第三方伪造发送。

加密算法

信息加密是非常专业的计算知识，通过复杂设计，对信息数据加密，使不能被轻易破解。常见的加密算法都需要有密钥，通过密钥分类又可以分为对称加密和非对称加密。

对称加密指信息的加密和解密使用同一个密钥，非对称加密则是信息的加密和解密不是用到同一个密钥

对称加密

AES

密码学中的高级加密标准（Advanced Encryption Standard，AES）

这个标准用来替代原先的DES（Data Encryption Standard），已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一 [1] 。

该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijdael之名命之，投稿高级加密标准的甄选流程。（Rijdael的发音近于 “Rhine doll”。）

原理

AES加密数据块和密钥长度可以是128b、192b、256b中的任意一个。AES加密有很多轮的重复和变换。大致步骤如下：①密钥扩展（Key Expansion)；②初始轮（InitialRound)；③重复轮（Rounds），每一重复轮又包括字节间减法运算（SubBytes）、行移位（ShiftRows）、列混合（MixColumns)、轮密钥加法运算（AddRoundKey)等操作；①最终轮（Final Round)，最终轮没有列混合操作（MixColumns)。

加密过程

128位密钥加密流程简略描述：

1
st=>start: 待加密明文
2
op0=>operation: 明文与密钥异或运算
3
op1=>operation: 获取加密密钥，设置填充方式
4
op2=>operation: 加密（信息+密钥 规律运算）
5
cond1=>condition: 循环了9次？
6
op3=>operation: 第十次加密运算（区别于前面9次）
7
op4=>operation: （明文+密钥）规律位运算调整
8
e=>end: AES加密密文
9

10
st->op0->op2->cond1
11
op3->e
12
cond1(yes)->op3
13
cond1(no)->op4->op2

解密（逆运算）

因为明文加密10轮是根据密钥有规律的复杂运算，因此解密就是上述过程的逆运算，只要有密钥，就能通过规律逆运算得到明文

加密模式

对称/分组密码一般分为流加密(如OFB、CFB等)和块加密(如ECB、CBC等)。对于流加密，需要将分组密码转化为流模式工作。对于块加密(或称分组加密)，如果要加密超过块大小的数据，就需要涉及填充和链加密模式。

ECB

ECB(Electronic Code Book电子密码本)模式

ECB模式是最早采用和最简单的模式，它将加密的数据分成若干组，每组的大小跟加密密钥长度相同，然后每组都用相同的密钥进行加密。

CBC

CBC(Cipher Block Chaining，加密块链)模式

这种模式是先将明文切分成若干小段，然后每一小段与初始块或者上一段的密文段进行异或运算后，再与密钥进行加密。

java使用AES加密

AesCrypto.java

1
package com.emoyc.note.common.util.encryption.aes;
2

3

4
import javax.crypto.Cipher;
5
import javax.crypto.KeyGenerator;
6
import javax.crypto.spec.IvParameterSpec;
7
import javax.crypto.spec.SecretKeySpec;
8

9
/**
10
 * AES加密
11
 * @author Narule
12
 *
13
 */
14
public class AesCrypto {
15

16
  /**
17
   * AES加密模式
18
   */
19

20
  private static final String ECB_MODE = "AES/ECB/PKCS5Padding";
21

22
  private static final String CBC_MODE = "AES/CBC/PKCS5Padding";
23

24

25
  /**
26
   * AES ECB模式加密
27
     * @param content 待加密的内容
28
     * @param encryptKey 加密密钥
29
     * @return 加密后的byte[]
30
     * @throws Exception
31
     */
32
    public static byte[] aesEncryptToBytes_ECB(byte[] contentBytes, byte[] keyBytes) throws Exception {
33
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
34
        kgen.init(128);
35
        Cipher cipher = Cipher.getInstance(ECB_MODE);
36
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(keyBytes, "AES"));
37
        return cipher.doFinal(contentBytes);
38
    }
39

40
  /**
41
   * AES ECB模式解密
42
   * @param encryptBytes 待解密的byte[]
43
     * @param decryptKey 解密密钥
44
     * @return 解密后的String
45
     * @throws Exception
46
     */
47
    public static byte[] aesDecryptByBytes_ECB(byte[] encryptBytes, byte[] keyBytes) throws Exception {
48
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
49
        kgen.init(128);
50
        Cipher cipher = Cipher.getInstance(ECB_MODE);
51
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, "AES"));
52
        return cipher.doFinal(encryptBytes);
53
    }
54

55

56

57
  /**
58
   * AES CBC模式加密
59
   * @throws Exception
60
   */
61
    public static byte[] aesEncryptToBytes_CBC(byte[] encryptBytes, byte[] ivBytes,byte[] keyBytes) throws Exception {
62
    SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
63
    IvParameterSpec IV = new IvParameterSpec(ivBytes);
64
    Cipher c = Cipher.getInstance(CBC_MODE);
65
    c.init(Cipher.ENCRYPT_MODE, key, IV);
66
    return c.doFinal(encryptBytes);
67
  }
68

69
  /**
70
   * AES CBC模式解密
71
   * @throws Exception
72
   */
73
    public static byte[] aesDecryptByBytes_CBC(byte[] decryptBytes, byte[] ivBytes,byte[] keyBytes) throws Exception {
74
      SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
75
    IvParameterSpec IV = new IvParameterSpec(ivBytes);
76
      Cipher c = Cipher.getInstance(CBC_MODE);
77
        c.init(Cipher.DECRYPT_MODE, key, IV);
78
        return c.doFinal(decryptBytes);
79
    }
80

81
}

AesUtil.java

1
package com.emoyc.note.common.util.encryption.aes;
2

3

4
/**
5
 * AES 加密整合工具类
6
 * @author Narule
7
 *
8
 */
9
public class AesUtil {
10

11
  /**
12
   * AES临时KEY
13
   */
14
  private static final String KEY = "jdkcnvlao903nhfl";
15

16

17
  /**
18
   * AES-ECB 加密模式
19
   * @param content //原文
20
   * @param key
21
   * @return _encrypt //密文
22
   * @throws Exception
23
   */
24
  public final static String aesEncrypt_ECB(String content,String key) throws Exception {
25
    return base64Encode(
26
          AesCrypto.aesEncryptToBytes_ECB(content.getBytes(), key.getBytes())
27
        );
28
  }
29

30
  /**
31
   * AES-ECB 解密模式
32
   * @param content //密文
33
   * @param key
34
   * @return _decrypt //原文
35
   * @throws Exception
36
   */
37
  public final static String aesDecrypt_ECB(String content,String key) throws Exception {
38
    return new String(
39
          AesCrypto.aesDecryptByBytes_ECB(base64Decode(content), key.getBytes())
40
        );
41
  }
42

43
  /**
44
   * AES-CBC 加密模式
45
   * @param content //原文
46
   * @param key
47
   * @return _encrypt //密文
48
   * @throws Exception
49
   */
50
  public final static String aesEncrypt_CBC(String content,String key) throws Exception {
51

52
    return base64Encode(
53
          AesCrypto.aesEncryptToBytes_CBC(content.getBytes(), key.getBytes(),key.getBytes())
54
        );
55
  }
56

57
  /**
58
   * AES-CBC 解密模式
59
   * @param content //密文
60
   * @param key
61
   * @return _decrypt //原文
62
   * @throws Exception
63
   */
64
  public final static String aesDecrypt_CBC(String content,String key) throws Exception {
65
    return new String(
66
          AesCrypto.aesDecryptByBytes_CBC(base64Decode(content), key.getBytes(), key.getBytes())
67
        );
68
  }
69

70

71
   /**
72
     * base 64 encode
73
     * @param bytes 待编码的byte[]
74
     * @return 编码后的base 64 code
75
     */
76
    public static String base64Encode(byte[] bytes){
77
      return java.util.Base64.getEncoder().encodeToString(bytes);
78
    }
79

80
    /**
81
     * base 64 decode
82
     * @param base64Code 待解码的base 64 code
83
     * @return 解码后的byte[]
84
     * @throws Exception
85
     */
86
    public static byte[] base64Decode(String base64Code) throws Exception{
87
       return (base64Code == null || base64Code.length() == 0) ? null : java.util.Base64.getDecoder().decode(base64Code);
88
    }
89

90

91

92

93

94

95

96

97

98

99
    public static void main(String[] args) {
100
      String string = "吴楠予";
101
    testAes_ECB(string);
102
    testAes_CBC(string);
103
  }
104

105
  private static void testAes_ECB(String string) {
106
    System.out.println("===================ECB加密=================");
107
    System.out.println("明文：" );
108
    System.out.println(string);
109
    String aesEncrypt_ECB = null;
110
    String aesDecrypt_ECB = null;
111
    try {
112
      aesEncrypt_ECB = aesEncrypt_ECB(string, KEY);
113
      System.out.println("密文：");
114
      System.out.println(aesEncrypt_ECB);
115
      aesDecrypt_ECB = aesDecrypt_ECB(aesEncrypt_ECB, KEY);
116
      System.out.println("解密后：");
117
      System.out.println(aesDecrypt_ECB);
118
    } catch (Exception e) {
119
      e.printStackTrace();
120
    }
121
  }
122

123
  private static void testAes_CBC(String string) {
124
    System.out.println("===================CBC加密=================");
125
    System.out.println("明文：" );
126
    System.out.println(string);
127
    String aesEncrypt_CBC = null;
128
    String aesDecrypt_CBC = null;
129
    try {
130
      aesEncrypt_CBC = aesEncrypt_CBC(string, KEY);
131
      System.out.println("密文：");
132
      System.out.println(aesEncrypt_CBC);
133
      aesDecrypt_CBC = aesDecrypt_CBC(aesEncrypt_CBC, KEY);
134
      System.out.println("解密后：");
135
      System.out.println(aesDecrypt_CBC);
136
    } catch (Exception e) {
137
      e.printStackTrace();
138
    }
139
  }
140

141
}

加解密Test

运行AesUtil的main方法：

非对称加密

RSA

参考文章

http://www.ruanyifeng.com/blog/2013/06/rsa_algorithm_part_one.html

http://www.ruanyifeng.com/blog/2013/07/rsa_algorithm_part_two.html

https://www.jianshu.com/p/ca659dbc6f46

通过上面的文章自己实践测试，数字小，但是不影响

1
p = 3 q = 5
2

3
n = 3 * 5 = 15
4

5
n' = 2 * 4 = 8
6

7
选一个数 e  与 8 互质
8
e = 7
9

10
7 * x + 8 * y = 1
11

12
x = 7 = d
13
y = -6
14

15

16
加密 3
17

18
3^7 = 2187
19

20
2187%15  = 12
21

22
12^7%15 = 3
23

24

25

26
e = ３
27

28
3 * x + 8 * y = 1
29

30
x = 11 = d
31
y = -4
32

33

34
加密 3
35

36
3^3 = 27
37

38
27%15  = 12
39

40
12^11%15 = 3

java使用RSA加密工具

RsaUtil.java

1
package com.emoyc.note.common.util.encryption.rsa;
2

3
import java.io.ByteArrayInputStream;
4
import java.io.ByteArrayOutputStream;
5
import java.io.File;
6
import java.io.FileInputStream;
7
import java.io.FileOutputStream;
8
import java.io.InputStream;
9
import java.io.OutputStream;
10
import java.security.KeyPair;
11

12
/**
13
 * RSA 加密工具整合类
14
 * @author Narule
15
 *
16
 */
17

18
public class RsaUtil {
19

20
  private static byte[] publicKey;
21
  private static byte[] privateKey;
22

23
  /**
24
   * main方法 - RSA 加密解密测试
25
   * @param args
26
   * @throws Exception
27
   */
28
  public static void main(String[] args) throws Exception {
29
    createKey();
30
    initKey();
31
    String str = "吴楠予";
32
    byte[] encryptData = RsaCrypto.encryptData(str.getBytes(), publicKey);
33
    System.out.println("=========加密===============");
34
    System.out.println(new String(encryptData));
35
    System.out.println("=========解密===============");
36
    byte[] decryptData = RsaCrypto.decryptData(encryptData, privateKey);
37
    System.out.println(new String(decryptData));
38
  }
39

40
  /**
41
   * createKey 创建RSA 密钥对
42
   */
43
  private static void createKey() {
44
      try {
45
        KeyPair generateKeyPair = RsaCrypto.creatKey();
46
        byteToFile(generateKeyPair.getPublic().getEncoded(), "./rsa_2048_pubkey.txt");
47
        byteToFile(generateKeyPair.getPrivate().getEncoded(), "./rsa_2048_prikey.txt");
48
      } catch (Exception e) {
49
        e.printStackTrace();
50
      }
51
    }
52

53
  public static KeyPair getOneRsaKey() {
54
      try {
55
        return RsaCrypto.creatKey();
56
      } catch (Exception e) {
57
        e.printStackTrace();
58
      }
59
      return null;
60
    }
61
  /**
62
   * readKey 读取密钥文件
63
   */
64
  private static void initKey() {
65
    try {
66
      publicKey =  fileToByte("./rsa_2048_pubkey.txt");
67
      privateKey =  fileToByte("./rsa_2048_prikey.txt");
68
    } catch (Exception e) {
69
      e.printStackTrace();
70
    }
71
  }
72

73

74

75
    /**
76
     * byte->file 二进制数据转文件
77
     * @param bytes
78
     * @param filePath
79
     * @throws Exception
80
     */
81
    public static void byteToFile(byte[] bytes, String filePath) throws Exception {
82
        InputStream in = new ByteArrayInputStream(bytes);
83
        File destFile = new File(filePath);
84
        if (!destFile.getParentFile().exists()) {
85
            destFile.getParentFile().mkdirs();
86
        }
87
        destFile.createNewFile();
88
        OutputStream out = new FileOutputStream(destFile);
89
        byte[] cache = new byte[2048];
90
        int nRead = 0;
91
        while ((nRead = in.read(cache)) != -1) {
92
            out.write(cache, 0, nRead);
93
            out.flush();
94
        }
95
        out.close();
96
        in.close();
97
    }
98

99

100
    /**
101
     * file->byte 文件转二进制
102
     * @param filePath
103
     * @return
104
     * @throws Exception
105
     */
106
    public static byte[] fileToByte(String filePath) throws Exception {
107
        byte[] data = new byte[0];
108
        File file = new File(filePath);
109
        if (file.exists()) {
110
            FileInputStream in = new FileInputStream(file);
111
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
112
            byte[] cache = new byte[2048];
113
            int nRead = 0;
114
            while ((nRead = in.read(cache)) != -1) {
115
                out.write(cache, 0, nRead);
116
                out.flush();
117
            }
118
            out.close();
119
            in.close();
120
            data = out.toByteArray();
121
        }
122
        return data;
123
    }
124
}

RsaCrypto.java

1
package com.emoyc.note.common.util.encryption.rsa;
2

3
import java.io.ByteArrayOutputStream;
4
import java.io.IOException;
5
import java.security.Key;
6
import java.security.KeyFactory;
7
import java.security.KeyPair;
8
import java.security.KeyPairGenerator;
9
import java.security.PublicKey;
10
import java.security.spec.PKCS8EncodedKeySpec;
11
import java.security.spec.X509EncodedKeySpec;
12

13
import javax.crypto.Cipher;
14

15

16
/**
17
 * RSA 加密解密类
18
 * @author Narule
19
 *
20
 */
21
public class RsaCrypto {
22

23
  private static final String ALGORITHM_RSA = "RSA";
24

25
  /** */
26
  /**
27
   * RSA最大加密明文大小
28
   */
29
  // 2048
30
  private static final int MAX_ENCRYPT_BLOCK = 245;
31

32
  /** */
33
  /**
34
   * RSA最大解密密文大小
35
   */
36
  // 2048
37
  private static final int MAX_DECRYPT_BLOCK = 256;
38

39

40

41
  public static KeyPair creatKey() throws Exception {
42
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM_RSA);
43
    keyPairGenerator.initialize(2048);
44
    return keyPairGenerator.generateKeyPair();
45
  }
46

47

48
  /**
49
   * RSA 公钥加密
50
   *
51
   * @param data
52
   * @param key
53
   * @return
54
   * @throws Exception
55
   */
56
  public static byte[] encryptData(byte[] data, byte[] key) {
57
    ByteArrayOutputStream out = null;
58
    byte[] encryptedData = null;
59
    try {
60
      X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
61
      KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
62
      PublicKey generatePublic = keyFactory.generatePublic(x509KeySpec);
63

64
      // 对数据加密
65
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
66
      cipher.init(Cipher.ENCRYPT_MODE, generatePublic);
67
      int inputLen = data.length;
68
      out = new ByteArrayOutputStream();
69
      int offSet = 0;
70
      byte[] cache;
71
      int i = 0;
72
      // 对数据分段加密
73
      while (inputLen - offSet > 0) {
74
        if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
75
          cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
76
        } else {
77
          cache = cipher.doFinal(data, offSet, inputLen - offSet);
78
        }
79
        out.write(cache, 0, cache.length);
80
        i++;
81
        offSet = i * MAX_ENCRYPT_BLOCK;
82
      }
83
      encryptedData = out.toByteArray();
84
      out.close();
85
    } catch (Exception e) {
86
      e.printStackTrace();
87
    } finally {
88
      // 防止流未关闭 浪费占用资源
89
      if (out != null) {
90
        try {
91
          out.close();
92
        } catch (IOException e) {
93
          e.printStackTrace();
94
        }
95
      }
96
    }
97
    return encryptedData;
98
  }
99

100
  /**
101
   * RSA 私钥解密
102
   *
103
   * @param data
104
   * @param key
105
   * @return
106
   * @throws Exception
107
   */
108
  public static byte[] decryptData(byte[] data, byte[] key) {
109
    ByteArrayOutputStream out = null;
110
    byte[] decryptedData = null;
111
    try {
112
      PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
113
      KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_RSA);
114
      Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
115
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
116
      cipher.init(Cipher.DECRYPT_MODE, privateK);
117
      out = new ByteArrayOutputStream();
118
      int inputLen = data.length;
119
      int offSet = 0;
120
      byte[] cache;
121
      int i = 0;
122
      // 对数据分段解密
123
      while (inputLen - offSet > 0) {
124
        if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
125
          cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
126
        } else {
127
          cache = cipher.doFinal(data, offSet, inputLen - offSet);
128
        }
129
        out.write(cache, 0, cache.length);
130
        i++;
131
        offSet = i * MAX_DECRYPT_BLOCK;
132
      }
133
      decryptedData = out.toByteArray();
134
      out.close();
135
    } catch (Exception e) {
136
      e.printStackTrace();
137
    } finally {
138
      // 防止流未关闭 浪费占用资源
139
      if (out != null) {
140
        try {
141
          out.close();
142
        } catch (IOException e) {
143
          e.printStackTrace();
144
        }
145
      }
146
    }
147
    return decryptedData;
148
  }
149

150
}

数据加密