basic functionality

privacy/privacy_test.go

@@ -0,0 +1,241 @@
+package privacy
+
+import (
+	"crypto/cipher"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"golang.org/x/crypto/argon2"
+	"golang.org/x/crypto/chacha20poly1305"
+	"io"
+	mr "math/rand"
+	"testing"
+)
+
+type tBuffer struct {
+	buf  []byte
+	rOff int
+}
+
+func newTBuf(size int) *tBuffer {
+	return &tBuffer{
+		buf: make([]byte, 0, size),
+	}
+}
+
+func (tb *tBuffer) Read(b []byte) (n int, err error) {
+	if tb.rOff == len(tb.buf) {
+		return 0, io.EOF
+	}
+
+	if len(b)+tb.rOff <= len(tb.buf) {
+		copy(b, tb.buf[tb.rOff:])
+		tb.rOff += len(b)
+		return len(b), nil
+	} else {
+		copy(b[:len(tb.buf)-tb.rOff], tb.buf[tb.rOff:])
+		n = len(tb.buf) - tb.rOff
+		err = nil
+		tb.rOff = len(tb.buf)
+		return
+	}
+}
+
+func (tb *tBuffer) Write(b []byte) (n int, err error) {
+	if len(tb.buf)+len(b) > cap(tb.buf) {
+		return 0, errors.New("insufficient space")
+	}
+
+	wOff := len(tb.buf)
+	tb.buf = tb.buf[:wOff+len(b)]
+	copy(tb.buf[wOff:], b)
+	return len(b), nil
+}
+
+func (tb *tBuffer) Close() error {
+	return nil
+}
+
+func TestReadWriteClose(t *testing.T) {
+	tb := newTBuf(70 * 1024)
+	keygen, err := NewArgon2WithParams(1, 4*1024, 2)
+	if err != nil {
+		t.Fatal("test preparation failure:", err)
+	}
+
+	passphrase := "some passphrase"
+
+	writer := NewPrivacyWriteCloserWithKeyGen(tb, DefaultCipherMethod, keygen)
+
+	t.Run("uninitialised salt", func(t *testing.T) {
+		err = writer.GenerateKey(passphrase)
+		if err == nil {
+			t.Fatal("unexpected: it should error")
+		}
+		if err != ErrUninitialisedSalt {
+			t.Fatal("unexpected error result:", err)
+		}
+	})
+
+	writer.SetSegmentSize(uint32(16 * 1024))
+
+	if err = writer.NewSalt(); err != nil {
+		t.Fatal("unexpected: NewSalt failed", err)
+	}
+	if err = writer.GenerateKey(passphrase); err != nil {
+		t.Fatal("unexpected: failed to generate key", err)
+	}
+
+	sha := sha256.New()
+	ur := mr.New(mr.NewSource(1))
+	bb := make([]byte, 1048)
+
+	var (
+		//bar int
+		n  int
+		wl int
+		rl int
+	)
+	for i := 0; i < 63; i++ {
+		//bar = 1000 + ur.Intn(49)
+		//ur.Read(bb[:bar])
+		//sha.Write(bb[:bar])
+		//if n, err = writer.Write(bb[:bar]); err != nil {
+		//	t.Fatal("unexpected: Write failed", err)
+		//}
+		ur.Read(bb)
+		sha.Write(bb)
+		if n, err = writer.Write(bb); err != nil {
+			t.Fatal("unexpected: Write failed", err)
+		}
+		wl += n
+	}
+
+	if err = writer.Close(); err != nil {
+		t.Fatal("unexpected: Close failed", err)
+	}
+
+	writeHash := sha.Sum(nil)
+	t.Log("write hash:", hex.EncodeToString(writeHash))
+
+	reader := NewPrivacyReaderWithKeyGen(tb, keygen)
+	reader.SetSegmentSize(uint32(16 * 1024))
+	if err = reader.ReadMagic(); err != nil {
+		t.Fatal("unexpected: ReadMagic failed", err)
+	}
+
+	if err = reader.GenerateKey(passphrase); err != nil {
+		t.Fatal("unexpected: GenerateKey failed", err)
+	}
+
+	sha.Reset()
+	err = nil
+	n = 0
+	for err == nil {
+		if n, err = reader.Read(bb); err != nil {
+			if err == io.EOF {
+				continue
+			} else {
+				t.Fatal("unexpected: Read failed", err)
+			}
+		}
+		rl += n
+		sha.Write(bb)
+	}
+
+	readHash := sha.Sum(nil)
+	t.Log("read hash:", hex.EncodeToString(readHash))
+
+	t.Log("wl", wl)
+	t.Log("rl", rl)
+	for i := range writeHash {
+		if readHash[i] != writeHash[i] {
+			t.Fatal("unexpected: mismatch hash")
+		}
+	}
+}
+
+func TestTrial(t *testing.T) {
+	x := make([]byte, 20)
+	for i := range x {
+		x[i] = byte(i)
+	}
+
+	t.Log("len x:", len(x))
+	t.Log("cap x:", cap(x))
+	t.Log("x:", x)
+
+	y := x[5:13]
+	t.Log("len y:", len(y))
+	t.Log("cap y:", cap(y))
+	t.Log("y:", y)
+
+	z := y[10:15]
+	t.Log("len z:", len(z))
+	t.Log("cap z:", cap(z))
+	t.Log("z:", z)
+}
+
+func TestKeyGen(t *testing.T) {
+	salt := make([]byte, 16)
+	_, err := rand.Read(salt)
+	if err != nil {
+		t.Fatal("unexpected error:", err)
+	}
+	passphrase := []byte("some passphrase")
+
+	key := argon2.IDKey(passphrase, salt, 1000, 64*1024, 8, 32)
+
+	_ = key
+	//keyCompare := argon2Params.IDKey(passphrase, salt, 100, 64*1024, 4, 32)
+	//
+	//for i := range key {
+	//	if key[i] != keyCompare[i] {
+	//		t.Fatal("unexpected result")
+	//	}
+	//}
+}
+
+func TestExample(t *testing.T) {
+	passphrase := []byte("some passphrase")
+	salt := make([]byte, 16)
+	_, err := rand.Read(salt)
+	if err != nil {
+		t.Fatal("error prepare salt", err)
+	}
+
+	key := argon2.IDKey(passphrase, salt, 1, 4*1024, 2, 32)
+
+	var aead cipher.AEAD
+	if aead, err = chacha20poly1305.NewX(key); err != nil {
+		t.Fatal("chacha", err)
+	}
+
+	ur := mr.New(mr.NewSource(1))
+	bb := make([]byte, 1024+aead.NonceSize()+aead.Overhead())
+
+	if _, err = rand.Read(bb[:aead.NonceSize()]); err != nil {
+		t.Fatal("fill up nonce", err)
+	}
+
+	additional := []byte("some additional data")
+	ur.Read(bb[aead.NonceSize() : aead.NonceSize()+1024])
+	before := sha256.Sum256(bb[aead.NonceSize() : aead.NonceSize()+1024])
+
+	aead.Seal(bb[aead.NonceSize():aead.NonceSize()], bb[:aead.NonceSize()], bb[aead.NonceSize():aead.NonceSize()+1024], additional)
+
+	if _, err = aead.Open(bb[aead.NonceSize():aead.NonceSize()],
+		bb[:aead.NonceSize()], bb[aead.NonceSize():aead.NonceSize()+1024+aead.Overhead()],
+		additional); err != nil {
+		t.Fatal("decrypt error", err)
+	}
+
+	after := sha256.Sum256(bb[aead.NonceSize() : aead.NonceSize()+1024])
+
+	for i := range before {
+		if before[i] != after[i] {
+			t.Fatal("data corruption?")
+		}
+	}
+}