go-sqlcrypter/crypter_test.go at master · bincyber/go-sqlcrypter · GitHub

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
package sqlcrypter

import (
	"bytes"
	"encoding/base64"
	"io"
	"testing"

	"github.com/pkg/errors"
	"github.com/stretchr/testify/require"
)

// base64Crypter exists only for test purposes
type base64Crypter struct{}

// Encrypt aka Encode
func (c *base64Crypter) Encrypt(w io.Writer, r io.Reader) error {
	src := new(bytes.Buffer)
	n, err := src.ReadFrom(r)
	if err != nil {
		return errors.Wrap(err, "failed to read from io.Reader")
	}

	dst := make([]byte, base64.StdEncoding.EncodedLen(int(n)))

	base64.StdEncoding.Encode(dst, src.Bytes())

	if _, err := w.Write(dst); err != nil {
		return errors.Wrap(err, "failed to write to io.Writer")
	}

	return nil
}

// Decrypt aka Decode
func (c *base64Crypter) Decrypt(w io.Writer, r io.Reader) error {
	src := new(bytes.Buffer)
	n, err := src.ReadFrom(r)
	if err != nil {
		return errors.Wrap(err, "failed to read from io.Reader")
	}

	dst := make([]byte, base64.StdEncoding.DecodedLen(int(n)))

	l, err := base64.StdEncoding.Decode(dst, src.Bytes())
	if err != nil {
		return errors.Wrap(err, "failed to base64 decode contents of io.Reader")
	}

	if _, err := w.Write(dst[:l]); err != nil {
		return errors.Wrap(err, "failed to write to io.Writer")
	}

	return nil
}

var _ Crypterer = (*base64Crypter)(nil)

func Test_Set(t *testing.T) {
	c := &base64Crypter{}
	err := Init(c)
	require.NoError(t, err)
	_, ok := crypter.(*base64Crypter)
	require.True(t, ok, "crypter should be a *base64Crypter after Init")
}

func Test_Init_Nil(t *testing.T) {
	err := Init(nil)
	require.Error(t, err)
	require.Contains(t, err.Error(), "Init() called with nil crypter")
	require.ErrorIs(t, err, ErrInitWithNil)
}

func Test_Encrypt(t *testing.T) {
	crypter = &base64Crypter{}

	plaintext := "Hello World"
	ciphertext := "SGVsbG8gV29ybGQ="

	reader := bytes.NewBufferString(plaintext)
	writer := new(bytes.Buffer)

	err := Encrypt(writer, reader)
	require.NoError(t, err)
	require.Equal(t, ciphertext, writer.String())
}

func Test_Encrypt_NotInitialized(t *testing.T) {
	prev := crypter
	t.Cleanup(func() {
		crypter = prev
	})

	crypter = nil

	reader := bytes.NewBufferString("Hello World")
	writer := new(bytes.Buffer)

	err := Encrypt(writer, reader)
	require.Error(t, err)
	require.ErrorIs(t, err, ErrCrypterNotInitialized)
}

func Test_Decrypt(t *testing.T) {
	crypter = &base64Crypter{}

	ciphertext := "SGVsbG8gV29ybGQ="
	plaintext := "Hello World"

	reader := bytes.NewBufferString(ciphertext)
	writer := new(bytes.Buffer)

	err := Decrypt(writer, reader)
	require.NoError(t, err)
	require.Equal(t, plaintext, writer.String())
}

func Test_Decrypt_NotInitialized(t *testing.T) {
	prev := crypter
	t.Cleanup(func() {
		crypter = prev
	})

	crypter = nil

	reader := bytes.NewBufferString("SGVsbG8gV29ybGQ=")
	writer := new(bytes.Buffer)

	err := Decrypt(writer, reader)
	require.Error(t, err)
	require.ErrorIs(t, err, ErrCrypterNotInitialized)
}