/
aes.go
141 lines (133 loc) · 4.42 KB
/
aes.go
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
// description: aes
// @author renshiwei
// Date: 2022/7/21 20:47
package cryptor
import (
"bytes"
"crypto/aes"
"encoding/base64"
)
// pkcs5补码算法
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
padText := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padText...)
}
// pkcs5减码算法
func pkcs5UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}
// AesEncryptByECBBase64
// ---------------AES ECB加密 Base64--------------------
// data: 明文数据
// key: 密钥字符串
// 返回密文数据
func AesEncryptByECBBase64(data, key string) string {
// 判断key长度
keyLenMap := map[int]struct{}{16: {}, 24: {}, 32: {}}
if _, ok := keyLenMap[len(key)]; !ok {
panic("key长度必须是 16、24、32 其中一个")
}
// 密钥和待加密数据转成[]byte
originByte := []byte(data)
keyByte := []byte(key)
// 创建密码组,长度只能是16、24、32字节
block, _ := aes.NewCipher(keyByte)
// 获取密钥长度
blockSize := block.BlockSize()
// 补码
originByte = pkcs5Padding(originByte, blockSize)
// 创建保存加密变量
encryptResult := make([]byte, len(originByte))
// CEB是把整个明文分成若干段相同的小段,然后对每一小段进行加密
for bs, be := 0, blockSize; bs < len(originByte); bs, be = bs+blockSize, be+blockSize {
block.Encrypt(encryptResult[bs:be], originByte[bs:be])
}
return base64.StdEncoding.EncodeToString(encryptResult)
}
// AesDecryptByECBBase64
// ---------------AES ECB解密 Base64--------------------
// data: 密文数据
// key: 密钥字符串
// 返回明文数据
func AesDecryptByECBBase64(data, key string) string {
// 判断key长度
keyLenMap := map[int]struct{}{16: {}, 24: {}, 32: {}}
if _, ok := keyLenMap[len(key)]; !ok {
panic("key长度必须是 16、24、32 其中一个")
}
// 反解密码base64
originByte, _ := base64.StdEncoding.DecodeString(data)
// 密钥和待加密数据转成[]byte
keyByte := []byte(key)
// 创建密码组,长度只能是16、24、32字节
block, _ := aes.NewCipher(keyByte)
// 获取密钥长度
blockSize := block.BlockSize()
// 创建保存解密变量
decrypted := make([]byte, len(originByte))
for bs, be := 0, blockSize; bs < len(originByte); bs, be = bs+blockSize, be+blockSize {
block.Decrypt(decrypted[bs:be], originByte[bs:be])
}
// 解码
return string(pkcs5UnPadding(decrypted))
}
// AesEncryptByECB
// ---------------AES ECB加密--------------------
// data: 明文数据
// key: 密钥字符串
// 返回密文数据
func AesEncryptByECB(data, key []byte) []byte {
// 判断key长度
keyLenMap := map[int]struct{}{16: {}, 24: {}, 32: {}}
if _, ok := keyLenMap[len(key)]; !ok {
panic("key长度必须是 16、24、32 其中一个")
}
// 密钥和待加密数据转成[]byte
originByte := data
keyByte := key
// 创建密码组,长度只能是16、24、32字节
block, _ := aes.NewCipher(keyByte)
// 获取密钥长度
blockSize := block.BlockSize()
// 补码
originByte = pkcs5Padding(originByte, blockSize)
// 创建保存加密变量
encryptResult := make([]byte, len(originByte))
// CEB是把整个明文分成若干段相同的小段,然后对每一小段进行加密
for bs, be := 0, blockSize; bs < len(originByte); bs, be = bs+blockSize, be+blockSize {
block.Encrypt(encryptResult[bs:be], originByte[bs:be])
}
//return base64.StdEncoding.EncodeToString(encryptResult)
return encryptResult
}
// AesDecryptByECB
// ---------------AES ECB解密--------------------
// data: 密文数据
// key: 密钥字符串
// 返回明文数据
func AesDecryptByECB(data, key []byte) []byte {
// 判断key长度
keyLenMap := map[int]struct{}{16: {}, 24: {}, 32: {}}
if _, ok := keyLenMap[len(key)]; !ok {
panic("key长度必须是 16、24、32 其中一个")
}
// 反解密码base64
//originByte, _ := base64.StdEncoding.DecodeString(data)
originByte := data
// 密钥和待加密数据转成[]byte
keyByte := key
// 创建密码组,长度只能是16、24、32字节
block, _ := aes.NewCipher(keyByte)
// 获取密钥长度
blockSize := block.BlockSize()
// 创建保存解密变量
decrypted := make([]byte, len(originByte))
for bs, be := 0, blockSize; bs < len(originByte); bs, be = bs+blockSize, be+blockSize {
block.Decrypt(decrypted[bs:be], originByte[bs:be])
}
// 解码
return pkcs5UnPadding(decrypted)
}