@@ -3,7 +3,6 @@ package encryption
33import (
44 "crypto/rand"
55 "encoding/base64"
6− "fmt"
76 "io"
87 "testing"
98
@@ -47,77 +46,55 @@ func TestEncodeAndDecodeAccessTokenB64(t *testing.T) {
4746
4847func TestEncryptAndDecrypt(t *testing.T) {
4948 // Test our 2 cipher types
50− ciphers := map[string]func([]byte) (Cipher, error){
49+ cipherInits := map[string]func([]byte) (Cipher, error){
5150 "CFB": NewCFBCipher,
5251 "GCM": NewGCMCipher,
5352 }
54− for name, initCipher := range ciphers {
55− // Test all 3 valid AES sizes
56− for _, secretSize := range []int{16, 24, 32} {
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)
61− assert.Equal(t, nil, err)
62−
63− c, err := initCipher(secret)
64− assert.Equal(t, nil, err)
65−
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)
53+ for name, initCipher := range cipherInits {
54+ t.Run(name, func(t *testing.T) {
55+ // Test all 3 valid AES sizes
56+ for _, secretSize := range []int{16, 24, 32} {
57+ t.Run(string(secretSize), func(t *testing.T) {
58+ secret := make([]byte, secretSize)
59+ _, err := io.ReadFull(rand.Reader, secret)
7060 assert.Equal(t, nil, err)
7161
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− })
82− }
83− }
84−}
85−
86−func TestEncryptAndDecryptBase64(t *testing.T) {
87− // Test our cipher types wrapped in Base64 encoder
88− ciphers := map[string]func([]byte) (Cipher, error){
89− "CFB": NewCFBCipher,
90− "GCM": NewGCMCipher,
91− }
92− for name, initCipher := range ciphers {
93− // Test all 3 valid AES sizes
94− for _, secretSize := range []int{16, 24, 32} {
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)
99− assert.Equal(t, nil, err)
100−
101− c, err := NewBase64Cipher(initCipher, secret)
102− assert.Equal(t, nil, err)
103−
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)
62+ // Test Standard & Base64 wrapped
63+ cstd, err := initCipher(secret)
10864 assert.Equal(t, nil, err)
10965
110− encrypted, err := c.Encrypt(data)
66+ cb64, err := NewBase64Cipher(initCipher, secret)
11167 assert.Equal(t, nil, err)
112− assert.NotEqual(t, encrypted, data)
11368
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− })
120− }
69+ ciphers := map[string]Cipher{
70+ "Standard": cstd,
71+ "Base64": cb64,
72+ }
73+
74+ for cName, c := range ciphers {
75+ t.Run(cName, func(t *testing.T) {
76+ // Test various sizes sessions might be
77+ for _, dataSize := range []int{10, 100, 1000, 5000, 10000} {
78+ t.Run(string(dataSize), func(t *testing.T) {
79+ data := make([]byte, dataSize)
80+ _, err := io.ReadFull(rand.Reader, data)
81+ assert.Equal(t, nil, err)
82+
83+ encrypted, err := c.Encrypt(data)
84+ assert.Equal(t, nil, err)
85+ assert.NotEqual(t, encrypted, data)
86+
87+ decrypted, err := c.Decrypt(encrypted)
88+ assert.Equal(t, nil, err)
89+ assert.Equal(t, data, decrypted)
90+ assert.NotEqual(t, encrypted, decrypted)
91+ })
92+ }
93+ })
94+ }
95+ })
96+ }
97+ })
12198 }
12299}
123100
@@ -161,12 +138,11 @@ func TestDecryptGCMWrongSecret(t *testing.T) {
161138 assert.Error(t, err)
162139}
163140
164−func TestIntermixCiphersErrors(t *testing.T) {
165− // Encrypt with GCM, Decrypt with CFB: Results in Garbage data
141+// Encrypt with GCM, Decrypt with CFB: Results in Garbage data
142+func TestGCMtoCFBErrors(t *testing.T) {
166143 // Test all 3 valid AES sizes
167144 for _, secretSize := range []int{16, 24, 32} {
168− subTestName := fmt.Sprintf("GCM->CFB::%d", secretSize)
169− t.Run(subTestName, func(t *testing.T) {
145+ t.Run(string(secretSize), func(t *testing.T) {
170146 secret := make([]byte, secretSize)
171147 _, err := io.ReadFull(rand.Reader, secret)
172148 assert.Equal(t, nil, err)
@@ -179,28 +155,31 @@ func TestIntermixCiphersErrors(t *testing.T) {
179155
180156 // Test various sizes sessions might be
181157 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)
158+ t.Run(string(dataSize), func(t *testing.T) {
159+ data := make([]byte, dataSize)
160+ _, err := io.ReadFull(rand.Reader, data)
161+ assert.Equal(t, nil, err)
162+
163+ encrypted, err := gcm.Encrypt(data)
164+ assert.Equal(t, nil, err)
165+ assert.NotEqual(t, encrypted, data)
166+
167+ decrypted, err := cfb.Decrypt(encrypted)
168+ assert.Equal(t, nil, err)
169+ // Data is mangled
170+ assert.NotEqual(t, data, decrypted)
171+ assert.NotEqual(t, encrypted, decrypted)
172+ })
195173 }
196174 })
197175 }
176+}
198177
199− // Encrypt with CFB, Decrypt with GCM: Results in errors
178+// Encrypt with CFB, Decrypt with GCM: Results in errors
179+func TestCFBtoGCMErrors(t *testing.T) {
200180 // Test all 3 valid AES sizes
201181 for _, secretSize := range []int{16, 24, 32} {
202− subTestName := fmt.Sprintf("CFB->GCM::%d", secretSize)
203− t.Run(subTestName, func(t *testing.T) {
182+ t.Run(string(secretSize), func(t *testing.T) {
204183 secret := make([]byte, secretSize)
205184 _, err := io.ReadFull(rand.Reader, secret)
206185 assert.Equal(t, nil, err)
@@ -213,17 +192,19 @@ func TestIntermixCiphersErrors(t *testing.T) {
213192
214193 // Test various sizes sessions might be
215194 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)
195+ t.Run(string(dataSize), func(t *testing.T) {
196+ data := make([]byte, dataSize)
197+ _, err := io.ReadFull(rand.Reader, data)
198+ assert.Equal(t, nil, err)
219199
220− encrypted, err := cfb.Encrypt(data)
221− assert.Equal(t, nil, err)
222− assert.NotEqual(t, encrypted, data)
200+ encrypted, err := cfb.Encrypt(data)
201+ assert.Equal(t, nil, err)
202+ assert.NotEqual(t, encrypted, data)
223203
224− // GCM is authenticated - this should lead to message authentication failed
225− _, err = gcm.Decrypt(encrypted)
226− assert.Error(t, err)
204+ // GCM is authenticated - this should lead to message authentication failed
205+ _, err = gcm.Decrypt(encrypted)
206+ assert.Error(t, err)
207+ })
227208 }
228209 })
229210 }