change computer

contract/best_contract.go

@@ -3,14 +3,22 @@ package contract
 import (
 	"errors"
 
+	"crypto/rsa"
 	"github.com/didiercrunch/filou/helper"
 )
 
+type GetRSAPrivateKey func() (*rsa.PrivateKey, error)
+
 type AcceptedContract struct {
-	Hash                  string
-	BlockCipher           string
-	BlockCipherMode       string
-	AsymetricCryptography string
+	Hash            string
+	BlockCipher     string
+	BlockCipherMode string
+
+	AsynchronousEncryptionScheme string
+	SignatureScheme              string
+
+	RsaPublicKey  *rsa.PublicKey
+	RsaPrivateKey GetRSAPrivateKey
 }
 
 func listContains(lst []string, elm string) bool {
@@ -31,6 +39,22 @@ func getFirstItemInList1ThatIsAlsoInList2(lst1, lst2 []string) (string, error) {
 	return "", errors.New("no items in list1 is in list2")
 }
 
+func getAsynchronousEncryptionScheme(prvCtr *PrivateContract, pubCtr *PublicContract) (string, error) {
+	if b, err := getFirstItemInList1ThatIsAlsoInList2(pubCtr.AcceptedAsynchronousEncryptionScheme, prvCtr.AcceptedAsynchronousEncryptionScheme); err != nil {
+		return "", errors.New("cannot find a asynchronous encryption scheme that satisfy both contracts")
+	} else {
+		return b, nil
+	}
+}
+
+func getSignatureScheme(prvCtr *PrivateContract, pubCtr *PublicContract) (string, error) {
+	if b, err := getFirstItemInList1ThatIsAlsoInList2(pubCtr.AcceptedSignatureScheme, prvCtr.AcceptedSignatureScheme); err != nil {
+		return "", errors.New("cannot find a signature scheme that satisfy both contracts")
+	} else {
+		return b, nil
+	}
+}
+
 func getBestBlockCipher(prvCtr *PrivateContract, pubCtr *PublicContract) (string, error) {
 	if b, err := getFirstItemInList1ThatIsAlsoInList2(pubCtr.AcceptedBlockCyphers, prvCtr.AcceptedBlockCyphers); err != nil {
 		return "", errors.New("cannot find a block cypher that satisfy both contracts")
@@ -68,6 +92,12 @@ func GetAcceptedContract(prvCtr *PrivateContract, pubCtr *PublicContract) (*Acce
 	if ret.BlockCipherMode, err = getBestBlockCipherMode(prvCtr, pubCtr); err != nil {
 		errs = append(errs, err.Error())
 	}
+	if ret.AsynchronousEncryptionScheme, err = getAsynchronousEncryptionScheme(prvCtr, pubCtr); err != nil {
+		errs = append(errs, err.Error())
+	}
+	if ret.SignatureScheme, err = getSignatureScheme(prvCtr, pubCtr); err != nil {
+		errs = append(errs, err.Error())
+	}
 
 	return ret, helper.JoinAsError(errs)
 }

contract/best_contract_test.go

@@ -48,6 +48,12 @@ func TestGetAcceptedContract(t *testing.T) {
 	pubCtr.AcceptedBlockCypherModes = []string{"ofb"}
 	prvCtr.AcceptedBlockCypherModes = []string{"ofb"}
 
+	pubCtr.AcceptedAsynchronousEncryptionScheme = []string{"rsa_oaep"}
+	prvCtr.AcceptedAsynchronousEncryptionScheme = []string{"rsa_oaep"}
+
+	pubCtr.AcceptedSignatureScheme = []string{"rsa_pss"}
+	prvCtr.AcceptedSignatureScheme = []string{"rsa_pss"}
+
 	ac, err := GetAcceptedContract(prvCtr, pubCtr)
 	if err != nil {
 		t.Error(err)
@@ -59,5 +65,11 @@ func TestGetAcceptedContract(t *testing.T) {
 	if ac.BlockCipher != "aes" {
 		t.Error("bad block cipher")
 	}
+	if ac.SignatureScheme != "rsa_pss" {
+		t.Error("bad signature scheme")
+	}
+	if ac.AsynchronousEncryptionScheme != "rsa_oaep" {
+		t.Error("bad asynchronous encryption scheme")
+	}
 
 }

contract/public_contract.go

@@ -5,8 +5,12 @@ import (
 )
 
 type PublicContract struct {
-	AcceptedHashes           []string             `yaml:"accepted_hashes" json:"accepted_hashes"`
-	AcceptedBlockCyphers     []string             `yaml:"accepted_block_cypher" json:"accepted_block_cypher"`
-	AcceptedBlockCypherModes []string             `yaml:"accepted_block_cypher_mode" json:"accepted_block_cypher_mode"`
-	RSAPublicKey             []*keys.RSAPublicKey `yaml:"rsa_public_key, omitempty" json:"rsa_public_key,omitempty"`
+	AcceptedHashes           []string `yaml:"accepted_hashes" json:"accepted_hashes"`
+	AcceptedBlockCyphers     []string `yaml:"accepted_block_cypher" json:"accepted_block_cypher"`
+	AcceptedBlockCypherModes []string `yaml:"accepted_block_cypher_mode" json:"accepted_block_cypher_mode"`
+
+	AcceptedAsynchronousEncryptionScheme []string `yaml:"accepted_asynchronous_encryption_scheme" json:"accepted_asynchronous_encryption_scheme"`
+	AcceptedSignatureScheme              []string `yaml:"accepted_signature_scheme" json:"accepted_signature_scheme"`
+
+	RSAPublicKey []*keys.RSAPublicKey `yaml:"rsa_public_key, omitempty" json:"rsa_public_key,omitempty"`
 }

contract/public_contract_test.go

@@ -38,7 +38,11 @@ func TestSimpleJsonification(t *testing.T) {
 	c := &PublicContract{
 		AcceptedHashes:       []string{"sha246"},
 		AcceptedBlockCyphers: []string{"aes"},
-		RSAPublicKey:         []*keys.RSAPublicKey{&keys.RSAPublicKey{helper.B(12), 3}},
+
+		AcceptedAsynchronousEncryptionScheme: []string{"rsa_oaep"},
+		AcceptedSignatureScheme:              []string{"rsa_pss"},
+
+		RSAPublicKey: []*keys.RSAPublicKey{&keys.RSAPublicKey{helper.B(12), 3}},
 	}
 	if err := assertJSONMarshalling(c); err != nil {
 		t.Error(err)
@@ -49,11 +53,20 @@ func TestEmptyRSAPublicKey(t *testing.T) {
 	c := &PublicContract{
 		AcceptedHashes:       []string{"sha246"},
 		AcceptedBlockCyphers: []string{"aes"},
-		RSAPublicKey:         []*keys.RSAPublicKey{&keys.RSAPublicKey{helper.B(12), 3}},
+
+		AcceptedAsynchronousEncryptionScheme: []string{"rsa_oaep"},
+		AcceptedSignatureScheme:              []string{"rsa_pss"},
+
+		RSAPublicKey: []*keys.RSAPublicKey{&keys.RSAPublicKey{helper.B(12), 3}},
 	}
 	jsonData := `{
 		"accepted_hashes": ["sha246"], 
 		"accepted_block_cypher": ["aes"],
+		
+		
+		"accepted_asynchronous_encryption_scheme":  ["rsa_oaep"],
+		"accepted_signature_scheme":  ["rsa_pss"],
+		
 		"rsa_public_key": [{"n": "c", "e": 3}]
 	}`
 	if err := expectJson(c, jsonData); err != nil {