Skip to content

Commit 1c895b7

Browse files
FishGoddessFishGoddess
committed
options 模式重构
1 parent 06630e7 commit 1c895b7

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+1421
-993
lines changed

‎aes/aes.go‎

Lines changed: 124 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,6 @@ import (
99
"crypto/aes"
1010
"crypto/cipher"
1111
"fmt"
12-
13-
"github.com/FishGoddess/cryptox/bytes/encoding"
14-
"github.com/FishGoddess/cryptox/bytes/padding"
1512
)
1613

1714
func newBlock(key []byte) (cipher.Block, int, error) {
@@ -25,14 +22,17 @@ func newBlock(key []byte) (cipher.Block, int, error) {
2522
}
2623

2724
// EncryptECB uses ecb mode to encrypt bs.
28-
func EncryptECB(bs []byte, key []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
25+
// It must specify a padding.
26+
func EncryptECB(bs []byte, key []byte, opts ...Option) ([]byte, error) {
27+
conf := newConfig().Apply(opts...)
28+
2929
block, blockSize, err := newBlock(key)
3030
if err != nil {
3131
return nil, err
3232
}
3333

3434
src := bytes.Clone(bs)
35-
src = padding.Pad(src, blockSize)
35+
src = conf.padding.Pad(src, blockSize)
3636
dst := bytes.Clone(src)
3737

3838
if len(src)%blockSize != 0 {
@@ -49,206 +49,236 @@ func EncryptECB(bs []byte, key []byte, padding padding.Padding, encoding encodin
4949
end += blockSize
5050
}
5151

52-
dst = encoding.Encode(dst)
52+
dst = conf.encoding.Encode(dst)
5353
return dst, nil
5454
}
5555

56-
// DecryptECB uses ecb mode to decrypt bs.
57-
func DecryptECB(bs []byte, key []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
58-
block, blockSize, err := newBlock(key)
59-
if err != nil {
60-
return nil, err
61-
}
56+
// EncryptCBC uses cbc mode to encrypt bs.
57+
// It must specify a padding.
58+
func EncryptCBC(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
59+
conf := newConfig().Apply(opts...)
6260

63-
src, err := encoding.Decode(bs)
61+
block, blockSize, err := newBlock(key)
6462
if err != nil {
6563
return nil, err
6664
}
6765

66+
src := bytes.Clone(bs)
67+
src = conf.padding.Pad(src, blockSize)
6868
dst := bytes.Clone(src)
6969

70-
if len(src)%blockSize != 0 {
71-
return nil, fmt.Errorf("cryptox/aes: decrypt ecb len(src) %d %% blockSize %d != 0", len(src), blockSize)
72-
}
73-
74-
start := 0
75-
end := blockSize
76-
77-
for end <= len(src) {
78-
block.Decrypt(dst[start:end], src[start:end])
79-
80-
start += blockSize
81-
end += blockSize
82-
}
83-
84-
return padding.Unpad(dst, blockSize)
70+
cipher.NewCBCEncrypter(block, iv).CryptBlocks(dst, src)
71+
dst = conf.encoding.Encode(dst)
72+
return dst, nil
8573
}
8674

87-
// EncryptCBC uses cbc mode to encrypt bs.
88-
func EncryptCBC(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
89-
block, blockSize, err := newBlock(key)
75+
// EncryptCFB uses cfb mode to encrypt bs.
76+
// There is no need to specify a padding.
77+
func EncryptCFB(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
78+
conf := newConfig().Apply(opts...)
79+
80+
block, _, err := newBlock(key)
9081
if err != nil {
9182
return nil, err
9283
}
9384

9485
src := bytes.Clone(bs)
95-
src = padding.Pad(src, blockSize)
9686
dst := bytes.Clone(src)
9787

98-
cipher.NewCBCEncrypter(block, iv).CryptBlocks(dst, src)
99-
dst = encoding.Encode(dst)
88+
cipher.NewCFBEncrypter(block, iv).XORKeyStream(dst, src)
89+
dst = conf.encoding.Encode(dst)
10090
return dst, nil
10191
}
10292

103-
// DecryptCBC uses cbc mode to decrypt bs.
104-
func DecryptCBC(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
105-
block, blockSize, err := newBlock(key)
106-
if err != nil {
107-
return nil, err
108-
}
93+
// EncryptOFB uses ofb mode to encrypt bs.
94+
// There is no need to specify a padding.
95+
func EncryptOFB(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
96+
conf := newConfig().Apply(opts...)
10997

110-
src, err := encoding.Decode(bs)
98+
block, _, err := newBlock(key)
11199
if err != nil {
112100
return nil, err
113101
}
114102

103+
src := bytes.Clone(bs)
115104
dst := bytes.Clone(src)
116105

117-
cipher.NewCBCDecrypter(block, iv).CryptBlocks(dst, src)
118-
return padding.Unpad(dst, blockSize)
106+
cipher.NewOFB(block, iv).XORKeyStream(dst, src)
107+
dst = conf.encoding.Encode(dst)
108+
return dst, nil
119109
}
120110

121-
// EncryptCFB uses cfb mode to encrypt bs.
122-
func EncryptCFB(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
123-
block, blockSize, err := newBlock(key)
111+
// EncryptCTR uses ctr mode to encrypt bs.
112+
// There is no need to specify a padding.
113+
func EncryptCTR(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
114+
conf := newConfig().Apply(opts...)
115+
116+
block, _, err := newBlock(key)
124117
if err != nil {
125118
return nil, err
126119
}
127120

128121
src := bytes.Clone(bs)
129-
src = padding.Pad(src, blockSize)
130122
dst := bytes.Clone(src)
131123

132-
cipher.NewCFBEncrypter(block, iv).XORKeyStream(dst, src)
133-
dst = encoding.Encode(dst)
124+
cipher.NewCTR(block, iv).XORKeyStream(dst, src)
125+
dst = conf.encoding.Encode(dst)
134126
return dst, nil
135127
}
136128

137-
// DecryptCFB uses cfb mode to decrypt bs.
138-
func DecryptCFB(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
139-
block, blockSize, err := newBlock(key)
129+
// EncryptGCM uses gcm mode to encrypt bs.
130+
// There is no need to specify a padding.
131+
func EncryptGCM(bs []byte, key []byte, nonce []byte, opts ...Option) ([]byte, error) {
132+
conf := newConfig().Apply(opts...)
133+
134+
block, _, err := newBlock(key)
140135
if err != nil {
141136
return nil, err
142137
}
143138

144-
src, err := encoding.Decode(bs)
139+
src := bs
140+
dst := bytes.Clone(src)
141+
dst = dst[:0]
142+
143+
gcm, err := cipher.NewGCM(block)
145144
if err != nil {
146145
return nil, err
147146
}
148147

149-
dst := bytes.Clone(src)
150-
151-
cipher.NewCFBDecrypter(block, iv).XORKeyStream(dst, src)
152-
return padding.Unpad(dst, blockSize)
148+
dst = gcm.Seal(dst, nonce, src, conf.additional)
149+
dst = conf.encoding.Encode(dst)
150+
return dst, nil
153151
}
154152

155-
// EncryptOFB uses ofb mode to encrypt bs.
156-
func EncryptOFB(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
153+
// DecryptECB uses ecb mode to decrypt bs.
154+
// It must specify a padding.
155+
func DecryptECB(bs []byte, key []byte, opts ...Option) ([]byte, error) {
156+
conf := newConfig().Apply(opts...)
157+
157158
block, blockSize, err := newBlock(key)
158159
if err != nil {
159160
return nil, err
160161
}
161162

162-
src := bytes.Clone(bs)
163-
src = padding.Pad(src, blockSize)
163+
src, err := conf.encoding.Decode(bs)
164+
if err != nil {
165+
return nil, err
166+
}
167+
164168
dst := bytes.Clone(src)
165169

166-
cipher.NewOFB(block, iv).XORKeyStream(dst, src)
167-
dst = encoding.Encode(dst)
168-
return dst, nil
170+
if len(src)%blockSize != 0 {
171+
return nil, fmt.Errorf("cryptox/aes: decrypt ecb len(src) %d %% blockSize %d != 0", len(src), blockSize)
172+
}
173+
174+
start := 0
175+
end := blockSize
176+
177+
for end <= len(src) {
178+
block.Decrypt(dst[start:end], src[start:end])
179+
180+
start += blockSize
181+
end += blockSize
182+
}
183+
184+
return conf.padding.Unpad(dst, blockSize)
169185
}
170186

171-
// DecryptOFB uses ofb mode to decrypt bs.
172-
func DecryptOFB(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
187+
// DecryptCBC uses cbc mode to decrypt bs.
188+
// It must specify a padding.
189+
func DecryptCBC(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
190+
conf := newConfig().Apply(opts...)
191+
173192
block, blockSize, err := newBlock(key)
174193
if err != nil {
175194
return nil, err
176195
}
177196

178-
src, err := encoding.Decode(bs)
197+
src, err := conf.encoding.Decode(bs)
179198
if err != nil {
180199
return nil, err
181200
}
182201

183202
dst := bytes.Clone(src)
184203

185-
cipher.NewOFB(block, iv).XORKeyStream(dst, src)
186-
return padding.Unpad(dst, blockSize)
204+
cipher.NewCBCDecrypter(block, iv).CryptBlocks(dst, src)
205+
return conf.padding.Unpad(dst, blockSize)
187206
}
188207

189-
// EncryptCTR uses ctr mode to encrypt bs.
190-
func EncryptCTR(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
191-
block, blockSize, err := newBlock(key)
208+
// DecryptCFB uses cfb mode to decrypt bs.
209+
// There is no need to specify a padding.
210+
func DecryptCFB(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
211+
conf := newConfig().Apply(opts...)
212+
213+
block, _, err := newBlock(key)
214+
if err != nil {
215+
return nil, err
216+
}
217+
218+
src, err := conf.encoding.Decode(bs)
192219
if err != nil {
193220
return nil, err
194221
}
195222

196-
src := bytes.Clone(bs)
197-
src = padding.Pad(src, blockSize)
198223
dst := bytes.Clone(src)
199224

200-
cipher.NewCTR(block, iv).XORKeyStream(dst, src)
201-
dst = encoding.Encode(dst)
225+
cipher.NewCFBDecrypter(block, iv).XORKeyStream(dst, src)
202226
return dst, nil
203227
}
204228

205-
// DecryptCTR uses ctr mode to decrypt bs.
206-
func DecryptCTR(bs []byte, key []byte, iv []byte, padding padding.Padding, encoding encoding.Encoding) ([]byte, error) {
207-
block, blockSize, err := newBlock(key)
229+
// DecryptOFB uses ofb mode to decrypt bs.
230+
// There is no need to specify a padding.
231+
func DecryptOFB(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
232+
conf := newConfig().Apply(opts...)
233+
234+
block, _, err := newBlock(key)
208235
if err != nil {
209236
return nil, err
210237
}
211238

212-
src, err := encoding.Decode(bs)
239+
src, err := conf.encoding.Decode(bs)
213240
if err != nil {
214241
return nil, err
215242
}
216243

217244
dst := bytes.Clone(src)
218245

219-
cipher.NewCTR(block, iv).XORKeyStream(dst, src)
220-
return padding.Unpad(dst, blockSize)
246+
cipher.NewOFB(block, iv).XORKeyStream(dst, src)
247+
return dst, nil
221248
}
222249

223-
// EncryptGCM uses gcm mode to encrypt bs.
224-
func EncryptGCM(bs []byte, key []byte, nonce []byte, additional []byte, encoding encoding.Encoding) ([]byte, error) {
250+
// DecryptCTR uses ctr mode to decrypt bs.
251+
// There is no need to specify a padding.
252+
func DecryptCTR(bs []byte, key []byte, iv []byte, opts ...Option) ([]byte, error) {
253+
conf := newConfig().Apply(opts...)
254+
225255
block, _, err := newBlock(key)
226256
if err != nil {
227257
return nil, err
228258
}
229259

230-
src := bs
231-
dst := bytes.Clone(src)
232-
dst = dst[:0]
233-
234-
gcm, err := cipher.NewGCM(block)
260+
src, err := conf.encoding.Decode(bs)
235261
if err != nil {
236262
return nil, err
237263
}
238264

239-
dst = gcm.Seal(dst, nonce, src, additional)
240-
dst = encoding.Encode(dst)
265+
dst := bytes.Clone(src)
266+
267+
cipher.NewCTR(block, iv).XORKeyStream(dst, src)
241268
return dst, nil
242269
}
243270

244271
// DecryptGCM uses gcm mode to decrypt bs.
245-
func DecryptGCM(bs []byte, key []byte, nonce []byte, additional []byte, encoding encoding.Encoding) ([]byte, error) {
272+
// There is no need to specify a padding.
273+
func DecryptGCM(bs []byte, key []byte, nonce []byte, opts ...Option) ([]byte, error) {
274+
conf := newConfig().Apply(opts...)
275+
246276
block, _, err := newBlock(key)
247277
if err != nil {
248278
return nil, err
249279
}
250280

251-
src, err := encoding.Decode(bs)
281+
src, err := conf.encoding.Decode(bs)
252282
if err != nil {
253283
return nil, err
254284
}
@@ -261,5 +291,5 @@ func DecryptGCM(bs []byte, key []byte, nonce []byte, additional []byte, encoding
261291
return nil, err
262292
}
263293

264-
return gcm.Open(dst, nonce, src, additional)
294+
return gcm.Open(dst, nonce, src, conf.additional)
265295
}

0 commit comments

Comments
 (0)