sprocess/aes_test.go at master · hyperboloide/sprocess · 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
package sprocess_test

import (
	"bytes"
	"crypto/rand"
	. "github.com/hyperboloide/sprocess"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"io"
)

var _ = Describe("Aes", func() {

	testBin := genBlob(1 << 22)
	out1 := new(bytes.Buffer)
	data := NewData()

	aes := &AES{
		Base64String: "ETl5QyPnHfi+vF4HrZfFvO2Julv4LVL7HNB1N7vkLGU=",
		Name:         "aes",
	}

	It("should have a name", func() {
		Ω(aes.GetName()).To(Equal("aes"))
	})

	It("should Encode", func() {
		Ω(aes.Start()).To(BeNil())
		Ω(aes.Encode(
			bytes.NewReader(testBin),
			out1,
			data)).To(BeNil())
		Ω(bytes.Equal(out1.Bytes(), testBin)).To(BeFalse())
		d, err := data.Get("iv")
		Ω(err).To(BeNil())
		Ω(len(d.(string)) > 0).To(BeTrue())
	})

	It("should Decode", func() {
		out2 := new(bytes.Buffer)
		Ω(aes.Decode(
			bytes.NewReader(out1.Bytes()),
			out2,
			data)).To(BeNil())
		Ω(bytes.Equal(out2.Bytes(), testBin)).To(BeTrue())
	})

	It("should work with []byte Key", func() {
		out1 := new(bytes.Buffer)
		data := NewData()
		key := make([]byte, 32)
		rand.Read(key)

		aes := &AES{
			Key:  key,
			Name: "aes",
		}

		Ω(aes.Start()).To(BeNil())
		Ω(aes.Encode(
			bytes.NewReader(testBin),
			out1,
			data)).To(BeNil())
		Ω(bytes.Equal(out1.Bytes(), testBin)).To(BeFalse())
		d, err := data.Get("iv")
		Ω(err).To(BeNil())
		Ω(len(d.(string)) > 0).To(BeTrue())

		out2 := new(bytes.Buffer)
		Ω(aes.Start()).To(BeNil())
		Ω(aes.Decode(
			bytes.NewReader(out1.Bytes()),
			out2,
			data)).To(BeNil())
		Ω(bytes.Equal(out2.Bytes(), testBin)).To(BeTrue())

	})

	It("should do service with aes", func() {
		data := NewData()
		id := "encrypted"

		fs := &File{
			Dir:  tmpDir(),
			Name: "fs",
		}
		Ω(fs.Start()).To(BeNil())

		key := make([]byte, 32)
		rand.Read(key)
		aes := &AES{
			Key:  key,
			Name: "aes",
		}
		Ω(aes.Start()).To(BeNil())

		chck := &CheckSum{
			Name: "chck",
		}
		Ω(chck.Start()).To(BeNil())

		service := &Service{
			EncodingPipe: &EncodingPipeline{
				Encoders: []Encoder{chck, aes},
				Output:   fs,
			},
			DecodingPipe: &DecodingPipeline{
				Decoders: []Decoder{aes, chck},
				Input:    fs,
			},
		}

		Ω(service.Encode(id, testFileReader(), data)).To(BeNil())
		d := data.Export()
		_, exists := d["chck"]
		Ω(exists).To(BeTrue())

		out := new(bytes.Buffer)
		r, w := io.Pipe()
		go func() {
			io.Copy(out, r)
		}()
		Ω(service.Decode(id, w, data)).To(BeNil())

	})

})