Add end to end decrypt encrypt func

crypto/symmetric/aes_test.go

@@ -30,6 +30,18 @@ const (
 )
 
 func TestEncryptDecryptWithPassword(t *testing.T) {
+	Convey("encrypt & decrypt 0 length string with aes256", t, func() {
+		enc, err := EncryptWithPassword([]byte(""), []byte(password), []byte(salt))
+		So(enc, ShouldNotBeNil)
+		So(len(enc), ShouldEqual, 2*aes.BlockSize)
+		So(err, ShouldBeNil)
+
+		dec, err := DecryptWithPassword(enc, []byte(password), []byte(salt))
+		So(dec, ShouldNotBeNil)
+		So(len(dec), ShouldEqual, 0)
+		So(err, ShouldBeNil)
+	})
+
 	Convey("encrypt & decrypt 0 length bytes with aes256", t, func() {
 		enc, err := EncryptWithPassword([]byte(nil), []byte(password), []byte(salt))
 		So(enc, ShouldNotBeNil)

xenomint/sqlite/sqlite.go

@@ -22,6 +22,7 @@ import (
 
 	sqlite3 "github.com/CovenantSQL/go-sqlite3-encrypt"
 
+	"github.com/CovenantSQL/CovenantSQL/crypto/symmetric"
 	"github.com/CovenantSQL/CovenantSQL/storage"
 	"github.com/CovenantSQL/CovenantSQL/utils/log"
 )
@@ -32,26 +33,50 @@ const (
 )
 
 func init() {
+	encryptFunc := func(in, pass, salt []byte) (out []byte, err error) {
+		out, err = symmetric.EncryptWithPassword(in, pass, salt)
+		return
+	}
+
+	decryptFunc := func(in, pass, salt []byte) (out []byte, err error) {
+		out, err = symmetric.DecryptWithPassword(in, pass, salt)
+		return
+	}
+
 	sleepFunc := func(t int64) int64 {
 		log.Info("sqlite func sleep start")
 		time.Sleep(time.Duration(t))
 		log.Info("sqlite func sleep end")
 		return t
 	}
+
+	regCustomFunc := func(c *sqlite3.SQLiteConn) (err error) {
+		if err = c.RegisterFunc("sleep", sleepFunc, true); err != nil {
+			return
+		}
+		if err = c.RegisterFunc("encrypt", encryptFunc, true); err != nil {
+			return
+		}
+		if err = c.RegisterFunc("decrypt", decryptFunc, true); err != nil {
+			return
+		}
+		return
+	}
+
 	sql.Register(dirtyReadDriver, &sqlite3.SQLiteDriver{
 		ConnectHook: func(c *sqlite3.SQLiteConn) (err error) {
 			if _, err = c.Exec("PRAGMA read_uncommitted=1", nil); err != nil {
 				return
 			}
-			if err = c.RegisterFunc("sleep", sleepFunc, true); err != nil {
+			if err = regCustomFunc(c); err != nil {
 				return
 			}
 			return
 		},
 	})
 	sql.Register(serializableDriver, &sqlite3.SQLiteDriver{
 		ConnectHook: func(c *sqlite3.SQLiteConn) (err error) {
-			if err = c.RegisterFunc("sleep", sleepFunc, true); err != nil {
+			if err = regCustomFunc(c); err != nil {
 				return
 			}
 			return

xenomint/sqlite/sqlite_test.go

@@ -22,6 +22,7 @@ import (
 	"math/rand"
 	"os"
 	"path"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
@@ -58,6 +59,34 @@ func TestStorage(t *testing.T) {
 			// Create basic table for testing
 			_, err = st.Writer().Exec(`CREATE TABLE "t1" ("k" INT, "v" TEXT, PRIMARY KEY("k"))`)
 			So(err, ShouldBeNil)
+
+			Convey("Test custom encrypt decrypt func", func() {
+				_, err = st.Writer().Exec(`INSERT INTO "t1" ("k", "v") VALUES (?, encrypt(?, "pass", "salt"))`, 0, "v0enc")
+				So(err, ShouldBeNil)
+				_, err = st.Writer().Exec(`INSERT INTO "t1" ("k", "v") VALUES (?, encrypt(?)`, 1, "v0enc")
+				So(err.Error(), ShouldContainSubstring, "incomplete input")
+				var destStr string
+				err = st.Reader().QueryRow(`SELECT "v" FROM "t1" WHERE "k"=?`, 0).Scan(&destStr)
+				So(err, ShouldBeNil)
+				So(destStr, ShouldNotContainSubstring, "enc")
+				err = st.Reader().QueryRow(`SELECT decrypt("v", "pass", "salt") FROM "t1" WHERE "k"=?`, 0).Scan(&destStr)
+				So(err, ShouldBeNil)
+				So(destStr, ShouldEqual, "v0enc")
+
+				var destSlice []byte
+				_, err = st.Writer().Exec(`UPDATE "t1" SET v = encrypt(@1, "pass", "salt") WHERE "k"=@2`, "", 0)
+				So(err, ShouldBeNil)
+				err = st.Reader().QueryRow(`SELECT decrypt("v", "pass", "salt") FROM "t1" WHERE "k"=?`, 0).Scan(&destSlice)
+				So(err, ShouldBeNil)
+				So(len(destSlice), ShouldEqual, 0)
+
+				largeText := strings.Repeat("s", 10000)
+				_, err = st.Writer().Exec(`UPDATE "t1" SET v = encrypt(:1, "pass", "salt") WHERE "k"=:2`, largeText, 0)
+				So(err, ShouldBeNil)
+				err = st.Reader().QueryRow(`SELECT decrypt("v", "pass", "salt") FROM "t1" WHERE "k"=?`, 0).Scan(&destStr)
+				So(err, ShouldBeNil)
+				So(destStr, ShouldEqual, largeText)
+			})
 			Convey("When storage is closed", func() {
 				err = st.Close()
 				So(err, ShouldBeNil)