[utilz] test cases for crypto

Author: explodes

userz/server.go

@@ -170,15 +170,15 @@ func (s *userzServer) serializeCookie(cookie *spb.Cookie) (string, error) {
 	if err != nil {
 		return "", errors.Wrap(err, "error serializing cookie")
 	}
-	serial, err := utilz.EncryptString(b, s.cookiePasscode)
+	serial, err := utilz.EncryptToBase64String(b, s.cookiePasscode)
 	if err != nil {
 		return "", errors.Wrap(err, "error encrypting cookie")
 	}
 	return serial, nil
 }
 
 func (s *userzServer) deserializeCookie(serial string) (*spb.Cookie, error) {
-	b, err := utilz.DecryptString(serial, s.cookiePasscode)
+	b, err := utilz.DecryptFromBase64String(serial, s.cookiePasscode)
 	if err != nil {
 		return nil, errors.Wrap(err, "error decrypting cookie")
 	}

utilz/crypto.go

@@ -30,7 +30,7 @@ func Encrypt(data []byte, passphrase string) ([]byte, error) {
 	return cipherText, nil
 }
 
-func EncryptString(data []byte, passphrase string) (string, error) {
+func EncryptToBase64String(data []byte, passphrase string) (string, error) {
 	b, err := Encrypt(data, passphrase)
 	if err != nil {
 		return "", err
@@ -57,7 +57,7 @@ func Decrypt(data []byte, passphrase string) ([]byte, error) {
 	return plainText, nil
 }
 
-func DecryptString(s string, passphrase string) ([]byte, error) {
+func DecryptFromBase64String(s string, passphrase string) ([]byte, error) {
 	b, err := base64.StdEncoding.DecodeString(s)
 	if err != nil {
 		return nil, err

utilz/crypto_test.go

@@ -0,0 +1,32 @@
+package utilz
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestEncrypt(t *testing.T) {
+	const passphrase = "test"
+	original := []byte("some text")
+	b, err := Encrypt(original, passphrase)
+	assert.NoError(t, err)
+	assert.NotEqual(t, original, b)
+
+	decrypted, err := Decrypt(b, passphrase)
+	assert.NoError(t, err)
+
+	assert.Equal(t, original, decrypted)
+}
+
+func TestEncryptBase64(t *testing.T) {
+	const passphrase = "test"
+	original := []byte("some text")
+	b64, err := EncryptToBase64String(original, passphrase)
+	assert.NoError(t, err)
+	assert.NotEqual(t, "some text", b64)
+
+	decrypted, err := DecryptFromBase64String(b64, passphrase)
+	assert.NoError(t, err)
+
+	assert.Equal(t, original, decrypted)
+}

utilz/dial.go

@@ -1,19 +1,30 @@
 package utilz
 
 import (
-	"github.com/explodes/serving/proto"
+	spb "github.com/explodes/serving/proto"
 	"github.com/pkg/errors"
 	"google.golang.org/grpc"
 )
 
 // DialGrpc dials a client connection taking into account dialing options.
-func DialGrpc(addr *proto.GrpcServer) (*grpc.ClientConn, error) {
-	if addr == nil || addr.Address == nil {
+func DialGrpc(serverConfig *spb.GrpcServer) (*grpc.ClientConn, error) {
+	if serverConfig == nil || serverConfig.Address == nil {
 		return nil, errors.New("address not specified")
 	}
-	conn, err := grpc.Dial(addr.Address.Address(), grpc.WithInsecure())
+	opts := grpcDialOptions(serverConfig)
+	conn, err := grpc.Dial(serverConfig.Address.Address(), opts...)
 	if err != nil {
 		return nil, errors.Wrap(err, "grpc dial error")
 	}
 	return conn, err
 }
+
+// grpcDialOptions extracts dial options from the GrpcServer config.
+func grpcDialOptions(serverConfig *spb.GrpcServer) []grpc.DialOption {
+	// TODO(evanleis): Add more features to GrpcServer.
+	// Desired features:
+	//  - backoff strategies
+	//  - security
+	//  - compression
+	return []grpc.DialOption{grpc.WithInsecure()}
+}