422 lines
9.5 KiB
Go
422 lines
9.5 KiB
Go
package encoder
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/aes"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"gogs.inhome.blapointe.com/local/encryptor"
|
|
"log"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func Test_Encoder2(t *testing.T) {
|
|
cases := []struct {
|
|
bops []BOP
|
|
streamLength int
|
|
bufferCapacity int
|
|
}{
|
|
{
|
|
bops: []BOP{
|
|
&AES{Key: []byte("key")},
|
|
},
|
|
streamLength: 75,
|
|
bufferCapacity: 25,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Salter{},
|
|
},
|
|
streamLength: 75,
|
|
bufferCapacity: 25,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
},
|
|
streamLength: 75,
|
|
bufferCapacity: 25,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&AES{Key: []byte("key")},
|
|
},
|
|
streamLength: 7500,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Salter{},
|
|
},
|
|
streamLength: 7500,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
},
|
|
streamLength: 7500,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte("key")},
|
|
},
|
|
streamLength: 75,
|
|
bufferCapacity: 50,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte("key")},
|
|
&Zipper{},
|
|
},
|
|
streamLength: 0,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte("key")},
|
|
&Zipper{},
|
|
},
|
|
streamLength: 76 * 1000,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte("key")},
|
|
&Zipper{},
|
|
},
|
|
streamLength: 7500,
|
|
bufferCapacity: 250,
|
|
},
|
|
{
|
|
bops: []BOP{
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte("key")},
|
|
&Zipper{},
|
|
},
|
|
streamLength: 75,
|
|
bufferCapacity: 25,
|
|
},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
log.Printf("test cap %v, input length %v, bop length %v", c.bufferCapacity, c.streamLength, len(c.bops))
|
|
SetPipeBuffSize(c.bufferCapacity)
|
|
enc, _ := New(nil, c.bops...)
|
|
input := strings.Repeat("hello world", c.streamLength)[:c.streamLength]
|
|
inputReader := strings.NewReader(input)
|
|
encodedReader, err := enc.Encode2(inputReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot encode2: %v", err)
|
|
}
|
|
encoded, err := ioutil.ReadAll(encodedReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot read encdoed: %v", err)
|
|
}
|
|
encodedReader = bytes.NewReader(encoded)
|
|
encodedBytes, err := ioutil.ReadAll(encodedReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot read encoded all: %v", err)
|
|
}
|
|
log.Printf("%v -> %v -> ?", c.streamLength, len(encodedBytes))
|
|
decodedReader, err := enc.Decode2(bytes.NewBuffer(encodedBytes))
|
|
if err != nil {
|
|
t.Fatalf("cannot decode2: %v", err)
|
|
}
|
|
out, err := ioutil.ReadAll(decodedReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot gather decoded: %v", err)
|
|
}
|
|
if string(out) != input {
|
|
t.Errorf("wrong encdoed-decoded: got %v, wanted %v", len(out), len(input))
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_Encoder3_Enc(t *testing.T) {
|
|
was := pipeBuffSize
|
|
defer func() {
|
|
SetPipeBuffSize(int(was))
|
|
}()
|
|
SetPipeBuffSize(aes.BlockSize + 2)
|
|
cases := []struct {
|
|
bops []BOP
|
|
}{
|
|
{bops: []BOP{&Salter{}}},
|
|
{bops: []BOP{&Zipper{}}},
|
|
{bops: []BOP{&Zipper{}, &Salter{}}},
|
|
{bops: []BOP{&Salter{}, &Zipper{}}},
|
|
{bops: []BOP{&AES{Key: []byte("key")}}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
title := "---"
|
|
for i := range c.bops {
|
|
title += fmt.Sprintf(" %T", c.bops[i])
|
|
}
|
|
enc, err := New(nil, c.bops...)
|
|
if err != nil {
|
|
t.Fatalf("cannot create new encoder: %v", err)
|
|
}
|
|
input := strings.Repeat("hello world", int(pipeBuffSize*2))[:pipeBuffSize*2]
|
|
inputReader := bytes.NewBuffer([]byte(input))
|
|
encodeReader, err := enc.Encode3(inputReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot get encode reader: %v", err)
|
|
}
|
|
out, err := ioutil.ReadAll(encodeReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot read from decode reader: %v", err)
|
|
}
|
|
t.Logf("%s : %s => %s", title, input, out)
|
|
}
|
|
}
|
|
func Test_Encoder3_All(t *testing.T) {
|
|
was := pipeBuffSize
|
|
defer func() {
|
|
SetPipeBuffSize(int(was))
|
|
}()
|
|
SetPipeBuffSize(aes.BlockSize + 2)
|
|
cases := []struct {
|
|
bops []BOP
|
|
}{
|
|
{bops: []BOP{&Salter{}}},
|
|
{bops: []BOP{&Zipper{}}},
|
|
{bops: []BOP{&AES{Key: []byte("key")}}},
|
|
{bops: []BOP{&Zipper{}, &Salter{}}},
|
|
{bops: []BOP{&Salter{}, &Zipper{}}},
|
|
{bops: []BOP{&Zipper{}, &Salter{}, &AES{Key: []byte("key")}, &Zipper{}}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
title := "///"
|
|
for i := range c.bops {
|
|
title += fmt.Sprintf(" %T", c.bops[i])
|
|
}
|
|
enc, err := New(nil, c.bops...)
|
|
if err != nil {
|
|
t.Fatalf("cannot create new encoder: %v", err)
|
|
}
|
|
input := strings.Repeat("hello world", int(pipeBuffSize*2))[:pipeBuffSize*2]
|
|
inputReader := bytes.NewBuffer([]byte(input))
|
|
encodeReader, err := enc.Encode3(inputReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot get encode reader: %v", err)
|
|
}
|
|
var decodeReader io.Reader
|
|
if false {
|
|
encodedString, err := ioutil.ReadAll(encodeReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot gather encoded: %v", err)
|
|
}
|
|
decodeReader, err = enc.Decode3(bytes.NewBuffer(encodedString))
|
|
} else {
|
|
decodeReader, err = enc.Decode3(encodeReader)
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("cannot get decode reader: %v", err)
|
|
}
|
|
out, err := ioutil.ReadAll(decodeReader)
|
|
if err != nil {
|
|
t.Fatalf("cannot read from decode reader: %v", err)
|
|
}
|
|
if string(out) != input {
|
|
t.Errorf("failed test with %v bops", len(c.bops))
|
|
}
|
|
t.Logf("%v : %s => %s", c.bops, input, out)
|
|
}
|
|
}
|
|
|
|
func Test_Encoder(t *testing.T) {
|
|
input := "My secret secret"
|
|
conf := &Config{
|
|
SymKey: "letme123in",
|
|
SymKeyOnly: false,
|
|
KeyPath: "",
|
|
}
|
|
enc, err := New(conf)
|
|
if err != nil {
|
|
t.Fatalf("cannot create new encoder: %v", err)
|
|
}
|
|
|
|
packed, err := enc.Encode([]byte(input), []byte("meta"), []byte("META 22222!!!!"))
|
|
if err != nil {
|
|
t.Fatalf("cannot encode with new encoder: %v", err)
|
|
}
|
|
unpacked, err := enc.Decode(packed)
|
|
if err != nil {
|
|
t.Fatalf("cannot decode with new encoder: %v", err)
|
|
}
|
|
if string(unpacked) != input {
|
|
t.Fatalf("unpacked != input: %v vs %v", string(unpacked), input)
|
|
}
|
|
|
|
packed, err = enc.Encode([]byte(input))
|
|
if err != nil {
|
|
t.Fatalf("cannot encode with new encoder: %v", err)
|
|
}
|
|
unpacked, err = enc.Decode(packed)
|
|
if err != nil {
|
|
t.Fatalf("cannot decode with new encoder: %v", err)
|
|
}
|
|
if string(unpacked) != input {
|
|
t.Fatalf("unpacked != input: %v vs %v", string(unpacked), input)
|
|
}
|
|
|
|
t.Logf("prepacked: %q, packed len: %v, unpacked: %q", input, len(packed), string(unpacked))
|
|
}
|
|
|
|
var metaname = []byte("META NAME")
|
|
var metavalue = []byte("META VALUE")
|
|
|
|
func Test_Encoder_BOP_Combos(t *testing.T) {
|
|
enc := encryptor.NewEncryptor("", "")
|
|
sym := encryptor.NewEncryptor("", "")
|
|
sym.SetSymmetric(sym.GetPublic())
|
|
|
|
encAndDec(t, makeSomeEnc(), "default")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Salter{},
|
|
&asymCryptor{Encryptor: enc},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&Zipper{},
|
|
), "salt_asym_sym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{},
|
|
&asymCryptor{Encryptor: enc},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&Zipper{},
|
|
), "zip_salt_asym_sym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&snapper{},
|
|
&Salter{},
|
|
&asymCryptor{Encryptor: enc},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&snapper{},
|
|
), "snap_salt_asym_sym_snap")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Salter{},
|
|
&asymCryptor{Encryptor: enc},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&Zipper{},
|
|
), "salt_asym_sym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{},
|
|
&asymCryptor{Encryptor: enc},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
), "zip_salt_asym_sym")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&asymCryptor{Encryptor: enc},
|
|
&Zipper{},
|
|
), "zip_salt_sym_asym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{n: 50},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&asymCryptor{Encryptor: enc},
|
|
&Zipper{},
|
|
), "zip_salt50_sym_asym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{n: 10},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&asymCryptor{Encryptor: enc},
|
|
&Zipper{},
|
|
), "zip_salt10_sym_asym_zip")
|
|
syms := []encryptor.Encryptor{}
|
|
for i := 0; i < 10; i++ {
|
|
e := encryptor.NewEncryptor("", "")
|
|
e.SetSymmetric(e.GetPublic())
|
|
syms = append(syms, e)
|
|
}
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
&Salter{n: 10},
|
|
&AES{Key: []byte(syms[0].GetPublic())},
|
|
&AES{Key: []byte(syms[1].GetPublic())},
|
|
&AES{Key: []byte(syms[2].GetPublic())},
|
|
&AES{Key: []byte(syms[3].GetPublic())},
|
|
&AES{Key: []byte(syms[4].GetPublic())},
|
|
&AES{Key: []byte(syms[5].GetPublic())},
|
|
&Zipper{},
|
|
), "zip_salt10_sym6_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Salter{n: 10},
|
|
&Zipper{},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&Zipper{},
|
|
), "salt10_zip_sym_zip")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Salter{n: 10},
|
|
&LZ4{},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&LZ4{},
|
|
), "salt10_lz4_sym_lz4")
|
|
encAndDec(t, makeSomeEnc(
|
|
&LZ4{},
|
|
&Salter{n: 10},
|
|
&AES{Key: []byte(sym.GetPublic())},
|
|
&LZ4{},
|
|
), "salt10_lz4_sym_lz4")
|
|
encAndDec(t, makeSomeEnc(
|
|
&LZ4{},
|
|
), "lz4")
|
|
encAndDec(t, makeSomeEnc(
|
|
&Zipper{},
|
|
), "zip")
|
|
}
|
|
|
|
func encAndDec(t *testing.T, enc *Encoder, name string) {
|
|
input := readSomeInput()
|
|
packed, err := enc.Encode(input, metaname, metavalue)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
unpacked, err := enc.Decode(packed)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(unpacked) != string(input) {
|
|
t.Fatalf("Unpacked != input: len %v vs %v", len(unpacked), len(input))
|
|
}
|
|
t.Logf("%30q: %4d -> %4d when packed (%d%%)", name, len(input), len(packed), 100.0*len(packed)/len(input))
|
|
}
|
|
|
|
func makeSomeEnc(bops ...BOP) *Encoder {
|
|
conf := &Config{
|
|
SymKey: "letme123in",
|
|
SymKeyOnly: false,
|
|
KeyPath: "",
|
|
}
|
|
e, err := New(conf, bops...)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return e
|
|
}
|
|
|
|
func readSomeInput() []byte {
|
|
b, err := ioutil.ReadFile("./encoder.go")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return b
|
|
}
|