-
Notifications
You must be signed in to change notification settings - Fork 0
/
aes_ecb.go
118 lines (99 loc) · 2.78 KB
/
aes_ecb.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
package wechat
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"errors"
"github.com/sohaha/zlsgo/zstring"
)
type ecb struct {
b cipher.Block
blockSize int
}
func newECB(b cipher.Block) *ecb {
return &ecb{
b: b,
blockSize: b.BlockSize(),
}
}
type ecbEncrypter ecb
func newECBEncrypter(b cipher.Block) cipher.BlockMode {
return (*ecbEncrypter)(newECB(b))
}
func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
if len(src)%x.blockSize != 0 {
panic("crypto/cipher: input not full blocks")
}
if len(dst) < len(src) {
panic("crypto/cipher: output smaller than input")
}
for len(src) > 0 {
x.b.Encrypt(dst, src[:x.blockSize])
src = src[x.blockSize:]
dst = dst[x.blockSize:]
}
}
type ecbDecrypter ecb
func newECBDecrypter(b cipher.Block) cipher.BlockMode {
return (*ecbDecrypter)(newECB(b))
}
func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
if len(src)%x.blockSize != 0 {
panic("crypto/cipher: input not full blocks")
}
if len(dst) < len(src) {
panic("crypto/cipher: output smaller than input")
}
for len(src) > 0 {
x.b.Decrypt(dst, src[:x.blockSize])
src = src[x.blockSize:]
dst = dst[x.blockSize:]
}
}
func aesECBEncrypt(plaintext, key string) (ciphertext []byte, err error) {
text := zstring.String2Bytes(plaintext)
text = pkcs5Padding(text, aes.BlockSize)
if len(text)%aes.BlockSize != 0 {
return nil, errors.New("plaintext is not a multiple of the block size")
}
aesKey := zstring.String2Bytes(key)
block, err := aes.NewCipher(aesKey)
if err != nil {
return nil, err
}
cipher := make([]byte, len(text))
newECBEncrypter(block).CryptBlocks(cipher, text)
base64Msg := make([]byte, base64.StdEncoding.EncodedLen(len(cipher)))
base64.StdEncoding.Encode(base64Msg, cipher)
return base64Msg, nil
}
func aesECBDecrypt(ciphertext, key string) (plaintext []byte, err error) {
text, _ := base64.StdEncoding.DecodeString(ciphertext)
if len(text) < aes.BlockSize {
return nil, errors.New("ciphertext too short")
}
if len(text)%aes.BlockSize != 0 {
return nil, errors.New("ciphertext is not a multiple of the block size")
}
aesKey := zstring.String2Bytes(key)
block, err := aes.NewCipher(aesKey)
if err != nil {
return nil, err
}
newECBDecrypter(block).CryptBlocks(text, text)
plaintext = pkcs5UnPadding(text)
return plaintext, nil
}
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
padding := blockSize - len(ciphertext)%blockSize
padtext := bytes.Repeat([]byte{byte(padding)}, padding)
return append(ciphertext, padtext...)
}
func pkcs5UnPadding(origData []byte) []byte {
length := len(origData)
unpadding := int(origData[length-1])
return origData[:(length - unpadding)]
}