@@ -3,6 +3,7 @@ package encryption
33import (
44 "crypto/rand"
55 "encoding/base64"
6+ "fmt"
67 "io"
78 "testing"
89
@@ -46,62 +47,76 @@ func TestEncodeAndDecodeAccessTokenB64(t *testing.T) {
4647
4748func TestEncryptAndDecrypt(t *testing.T) {
4849 // Test our 2 cipher types
49− for _, initCipher := range []func([]byte) (Cipher, error){NewCFBCipher, NewGCMCipher} {
50+ ciphers := map[string]func([]byte) (Cipher, error){
51+ "CFB": NewCFBCipher,
52+ "GCM": NewGCMCipher,
53+ }
54+ for name, initCipher := range ciphers {
5055 // Test all 3 valid AES sizes
5156 for _, secretSize := range []int{16, 24, 32} {
52− secret := make([]byte, secretSize)
53− _, err := io.ReadFull(rand.Reader, secret)
54− assert.Equal(t, nil, err)
55−
56− c, err := initCipher(secret)
57− assert.Equal(t, nil, err)
58−
59− // Test various sizes sessions might be
60− for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
61− data := make([]byte, dataSize)
62− _, err := io.ReadFull(rand.Reader, data)
57+ subTestName := fmt.Sprintf("%s::%d", name, secretSize)
58+ t.Run(subTestName, func(t *testing.T) {
59+ secret := make([]byte, secretSize)
60+ _, err := io.ReadFull(rand.Reader, secret)
6361 assert.Equal(t, nil, err)
6462
65− encrypted, err := c.Encrypt(data)
63+ c, err := initCipher(secret)
6664 assert.Equal(t, nil, err)
67− assert.NotEqual(t, encrypted, data)
6865
69− decrypted, err := c.Decrypt(encrypted)
70− assert.Equal(t, nil, err)
71− assert.Equal(t, data, decrypted)
72− assert.NotEqual(t, encrypted, decrypted)
73− }
66+ // Test various sizes sessions might be
67+ for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
68+ data := make([]byte, dataSize)
69+ _, err := io.ReadFull(rand.Reader, data)
70+ assert.Equal(t, nil, err)
71+
72+ encrypted, err := c.Encrypt(data)
73+ assert.Equal(t, nil, err)
74+ assert.NotEqual(t, encrypted, data)
75+
76+ decrypted, err := c.Decrypt(encrypted)
77+ assert.Equal(t, nil, err)
78+ assert.Equal(t, data, decrypted)
79+ assert.NotEqual(t, encrypted, decrypted)
80+ }
81+ })
7482 }
7583 }
7684}
7785
7886func TestEncryptAndDecryptBase64(t *testing.T) {
7987 // Test our cipher types wrapped in Base64 encoder
80− for _, initCipher := range []func([]byte) (Cipher, error){NewCFBCipher, NewGCMCipher} {
88+ ciphers := map[string]func([]byte) (Cipher, error){
89+ "CFB": NewCFBCipher,
90+ "GCM": NewGCMCipher,
91+ }
92+ for name, initCipher := range ciphers {
8193 // Test all 3 valid AES sizes
8294 for _, secretSize := range []int{16, 24, 32} {
83− secret := make([]byte, secretSize)
84− _, err := io.ReadFull(rand.Reader, secret)
85− assert.Equal(t, nil, err)
86−
87− c, err := NewBase64Cipher(initCipher, secret)
88− assert.Equal(t, nil, err)
89−
90− // Test various sizes sessions might be
91− for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
92− data := make([]byte, dataSize)
93− _, err := io.ReadFull(rand.Reader, data)
95+ subTestName := fmt.Sprintf("%s::%d", name, secretSize)
96+ t.Run(subTestName, func(t *testing.T) {
97+ secret := make([]byte, secretSize)
98+ _, err := io.ReadFull(rand.Reader, secret)
9499 assert.Equal(t, nil, err)
95100
96− encrypted, err := c.Encrypt(data)
101+ c, err := NewBase64Cipher(initCipher, secret)
97102 assert.Equal(t, nil, err)
98− assert.NotEqual(t, encrypted, data)
99103
100− decrypted, err := c.Decrypt(encrypted)
101− assert.Equal(t, nil, err)
102− assert.Equal(t, data, decrypted)
103− assert.NotEqual(t, encrypted, decrypted)
104− }
104+ // Test various sizes sessions might be
105+ for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
106+ data := make([]byte, dataSize)
107+ _, err := io.ReadFull(rand.Reader, data)
108+ assert.Equal(t, nil, err)
109+
110+ encrypted, err := c.Encrypt(data)
111+ assert.Equal(t, nil, err)
112+ assert.NotEqual(t, encrypted, data)
113+
114+ decrypted, err := c.Decrypt(encrypted)
115+ assert.Equal(t, nil, err)
116+ assert.Equal(t, data, decrypted)
117+ assert.NotEqual(t, encrypted, decrypted)
118+ }
119+ })
105120 }
106121 }
107122}
@@ -150,61 +165,67 @@ func TestIntermixCiphersErrors(t *testing.T) {
150165 // Encrypt with GCM, Decrypt with CFB: Results in Garbage data
151166 // Test all 3 valid AES sizes
152167 for _, secretSize := range []int{16, 24, 32} {
153− secret := make([]byte, secretSize)
154− _, err := io.ReadFull(rand.Reader, secret)
155− assert.Equal(t, nil, err)
156−
157− gcm, err := NewGCMCipher(secret)
158− assert.Equal(t, nil, err)
159−
160− cfb, err := NewCFBCipher(secret)
161− assert.Equal(t, nil, err)
162−
163− // Test various sizes sessions might be
164− for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
165− data := make([]byte, dataSize)
166− _, err := io.ReadFull(rand.Reader, data)
168+ subTestName := fmt.Sprintf("GCM->CFB::%d", secretSize)
169+ t.Run(subTestName, func(t *testing.T) {
170+ secret := make([]byte, secretSize)
171+ _, err := io.ReadFull(rand.Reader, secret)
167172 assert.Equal(t, nil, err)
168173
169− encrypted, err := gcm.Encrypt(data)
174+ gcm, err := NewGCMCipher(secret)
170175 assert.Equal(t, nil, err)
171− assert.NotEqual(t, encrypted, data)
172176
173− decrypted, err := cfb.Decrypt(encrypted)
177+ cfb, err := NewCFBCipher(secret)
174178 assert.Equal(t, nil, err)
175− // Data is mangled
176− assert.NotEqual(t, data, decrypted)
177− assert.NotEqual(t, encrypted, decrypted)
178− }
179+
180+ // Test various sizes sessions might be
181+ for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
182+ data := make([]byte, dataSize)
183+ _, err := io.ReadFull(rand.Reader, data)
184+ assert.Equal(t, nil, err)
185+
186+ encrypted, err := gcm.Encrypt(data)
187+ assert.Equal(t, nil, err)
188+ assert.NotEqual(t, encrypted, data)
189+
190+ decrypted, err := cfb.Decrypt(encrypted)
191+ assert.Equal(t, nil, err)
192+ // Data is mangled
193+ assert.NotEqual(t, data, decrypted)
194+ assert.NotEqual(t, encrypted, decrypted)
195+ }
196+ })
179197 }
180198
181199 // Encrypt with CFB, Decrypt with GCM: Results in errors
182200 // Test all 3 valid AES sizes
183201 for _, secretSize := range []int{16, 24, 32} {
184− secret := make([]byte, secretSize)
185− _, err := io.ReadFull(rand.Reader, secret)
186− assert.Equal(t, nil, err)
187−
188− gcm, err := NewGCMCipher(secret)
189− assert.Equal(t, nil, err)
190−
191− cfb, err := NewCFBCipher(secret)
192− assert.Equal(t, nil, err)
202+ subTestName := fmt.Sprintf("CFB->GCM::%d", secretSize)
203+ t.Run(subTestName, func(t *testing.T) {
204+ secret := make([]byte, secretSize)
205+ _, err := io.ReadFull(rand.Reader, secret)
206+ assert.Equal(t, nil, err)
193207
194− // Test various sizes sessions might be
195− for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
196− data := make([]byte, dataSize)
197− _, err := io.ReadFull(rand.Reader, data)
208+ gcm, err := NewGCMCipher(secret)
198209 assert.Equal(t, nil, err)
199210
200− encrypted, err := cfb.Encrypt(data)
211+ cfb, err := NewCFBCipher(secret)
201212 assert.Equal(t, nil, err)
202− assert.NotEqual(t, encrypted, data)
203213
204− // GCM is authenticated - this should lead to message authentication failed
205− _, err = gcm.Decrypt(encrypted)
206− assert.Error(t, err)
207− }
214+ // Test various sizes sessions might be
215+ for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
216+ data := make([]byte, dataSize)
217+ _, err := io.ReadFull(rand.Reader, data)
218+ assert.Equal(t, nil, err)
219+
220+ encrypted, err := cfb.Encrypt(data)
221+ assert.Equal(t, nil, err)
222+ assert.NotEqual(t, encrypted, data)
223+
224+ // GCM is authenticated - this should lead to message authentication failed
225+ _, err = gcm.Decrypt(encrypted)
226+ assert.Error(t, err)
227+ }
228+ })
208229 }
209230}
210231