From 52a13b9cab94e901b93e65c162c13e59aa54b99c Mon Sep 17 00:00:00 2001
From: "didier.amyot" <didier.amyot@gmail.com>
Date: Sat, 1 Nov 2014 19:30:24 -0700
Subject: [PATCH] my computer will still die soon

---
 helper/helper.go        | 10 ++++++++++
 helper/helper_test.go   | 17 +++++++++++++++++
 payload/block.go        |  8 +++++---
 payload/blockmode.go    | 10 ++++++++++
 payload/hash.go         |  2 +-
 payload/payload.go      |  9 ++++++++-
 payload/payload_test.go | 12 +++++++++++-
 7 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/helper/helper.go b/helper/helper.go
index a9f38d0..5ef16de 100644
--- a/helper/helper.go
+++ b/helper/helper.go
@@ -11,3 +11,13 @@ func JoinAsError(msg []string) error {
 	}
 	return nil
 }
+
+func JoinErrors(errs []error) error {
+	msgs := make([]string, 0, len(errs))
+	for _, err := range errs {
+		if err != nil {
+			msgs = append(msgs, err.Error())
+		}
+	}
+	return JoinAsError(msgs)
+}
diff --git a/helper/helper_test.go b/helper/helper_test.go
index 27d491c..6d9085e 100644
--- a/helper/helper_test.go
+++ b/helper/helper_test.go
@@ -1,6 +1,7 @@
 package helper
 
 import (
+	"errors"
 	"testing"
 )
 
@@ -19,3 +20,19 @@ func TestJoinAsError(t *testing.T) {
 		t.Error("bad error")
 	}
 }
+
+func TestJoinErrors(t *testing.T) {
+	var errs []error = nil
+	if JoinErrors(errs) != nil {
+		t.Error("expected no errors")
+	}
+	errs = make([]error, 0)
+	if JoinErrors(errs) != nil {
+		t.Error("expected no errors")
+	}
+
+	errs = []error{errors.New("a"), errors.New("b")}
+	if JoinErrors(errs).Error() != "a\nb" {
+		t.Error("bad error")
+	}
+}
diff --git a/payload/block.go b/payload/block.go
index 396d53b..8660f6f 100644
--- a/payload/block.go
+++ b/payload/block.go
@@ -47,9 +47,11 @@ func (this Block) CreateBlock(rd io.Reader) (cipher.Block, []byte, error) {
 }
 
 func GetBlockByBlockName(blockName string) (Block, error) {
-	ret := Hash(hashName)
-	if _, err := ret.New(); err != nil {
+	ret := Block(blockName)
+	switch ret {
+	case AES256:
+		return ret, nil
+	default:
 		return "", errors.New("block encryption " + blockName + " is not supported")
 	}
-	return ret, nil
 }
diff --git a/payload/blockmode.go b/payload/blockmode.go
index 34216ad..b596522 100644
--- a/payload/blockmode.go
+++ b/payload/blockmode.go
@@ -43,3 +43,13 @@ func (this BlockMode) GetCipherStream(block cipher.Block, rd io.Reader) (stream
 	}
 	return streamCreator(block, iv), iv, nil
 }
+
+func GetBlockModeByName(blockModeName string) (BlockMode, error) {
+	ret := BlockMode(blockModeName)
+	switch ret {
+	case OFB:
+		return ret, nil
+	default:
+		return "", errors.New("block mode " + blockModeName + " is not supported")
+	}
+}
diff --git a/payload/hash.go b/payload/hash.go
index ad9fa58..317a214 100644
--- a/payload/hash.go
+++ b/payload/hash.go
@@ -25,7 +25,7 @@ func (this Hash) New() (hash.Hash, error) {
 	case SHA512:
 		return cryptoSHA512.New(), nil
 	default:
-		msg := fmt.Sprintf("hash '%s' is not supported")
+		msg := fmt.Sprintf("hash '%s' is not supported", this)
 		return nil, errors.New(msg)
 	}
 }
diff --git a/payload/payload.go b/payload/payload.go
index f9ef5c8..2f0f160 100644
--- a/payload/payload.go
+++ b/payload/payload.go
@@ -8,6 +8,7 @@ import (
 	"io"
 
 	"github.com/didiercrunch/filou/contract"
+	"github.com/didiercrunch/filou/helper"
 )
 
 type BlockModeStream func(block cipher.Block, iv []byte) cipher.Stream
@@ -41,8 +42,14 @@ func GetPayload(dataSource io.Reader, acceptedContract *contract.AcceptedContrac
 	if ret.HashMethod, err = GetHashByHashName(acceptedContract.Hash); err != nil {
 		errs = append(errs, err)
 	}
+	if ret.Block, err = GetBlockByBlockName(acceptedContract.BlockCipher); err != nil {
+		errs = append(errs, err)
+	}
+	if ret.BlockMode, err = GetBlockModeByName(acceptedContract.BlockCipherMode); err != nil {
+		errs = append(errs, err)
+	}
 
-	return ret, nil
+	return ret, helper.JoinErrors(errs)
 }
 
 type payloadWriter struct {
diff --git a/payload/payload_test.go b/payload/payload_test.go
index e2543d8..9db53b9 100644
--- a/payload/payload_test.go
+++ b/payload/payload_test.go
@@ -170,7 +170,11 @@ func TestGetDefaultPayload(t *testing.T) {
 }
 
 func TestGetPayload(t *testing.T) {
-	c := &contract.AcceptedContract{Hash: "sha512"}
+	c := &contract.AcceptedContract{
+		Hash:            "sha512",
+		BlockCipher:     "aes256",
+		BlockCipherMode: "ofb",
+	}
 	p, err := GetPayload(nil, c)
 	if err != nil {
 		t.Error(err)
@@ -186,5 +190,11 @@ func TestGetPayload(t *testing.T) {
 	if p.HashMethod != expectedPayload.HashMethod {
 		t.Error("bad hash method")
 	}
+	if p.Block != expectedPayload.Block {
+		t.Error("bad block method", p.Block)
+	}
+	if p.BlockMode != expectedPayload.BlockMode {
+		t.Error("bad block method", p.Block)
+	}
 
 }