Second round of bson extraction

2018-06-13 11:27:43 -04:00
1 parent c0e04321bb
commit d038e085a3
@@ -0,0 +1,231 @@
+package bson
+
+//  all the methods relative to the set/get json/bson should be stored
+//  in this file.
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/keep-network/paillier"
+	"gopkg.in/mgo.v2/bson"
+)
+
+type Cypher paillier.Cypher
+type ThresholdPublicKey paillier.ThresholdPublicKey
+type PublicKey paillier.PublicKey
+type PrivateKey paillier.PrivateKey
+type PartialDecryptionZKP paillier.PartialDecryptionZKP
+
+type dbCypher struct {
+	C string
+}
+
+func (cypher *Cypher) GetBSON() (interface{}, error) {
+	return &dbCypher{fmt.Sprintf("%x", cypher.C)}, nil
+}
+
+func (cypher *Cypher) SetBSON(raw bson.Raw) error {
+	c := dbCypher{}
+	if err := raw.Unmarshal(&c); err != nil {
+		return err
+	}
+	var ok bool
+	cypher.C, ok = new(big.Int).SetString(c.C, 16)
+	if !ok {
+		return errors.New("big int not in hexadecimal format")
+	}
+	return nil
+}
+
+type dbThresholdKey struct {
+	TotalNumberOfDecryptionServers int
+	Threshold                      int
+	V                              string
+	Vi                             []string
+	N                              string
+}
+
+func (dbThresholdKey *dbThresholdKey) FromThresholdPublicKey(key *ThresholdPublicKey) {
+	dbThresholdKey.TotalNumberOfDecryptionServers = key.TotalNumberOfDecryptionServers
+	dbThresholdKey.Threshold = key.Threshold
+	dbThresholdKey.V = fmt.Sprintf("%x", key.V)
+	dbThresholdKey.N = fmt.Sprintf("%x", key.N)
+	dbThresholdKey.Vi = make([]string, len(key.Vi))
+	for i, vi := range key.Vi {
+		dbThresholdKey.Vi[i] = fmt.Sprintf("%x", vi)
+	}
+}
+
+func (dbThresholdKey *dbThresholdKey) ToThresholdPublicKey(key *ThresholdPublicKey) error {
+	key.TotalNumberOfDecryptionServers = dbThresholdKey.TotalNumberOfDecryptionServers
+	key.Threshold = dbThresholdKey.Threshold
+	oks := make([]bool, 2)
+	key.V, oks[0] = new(big.Int).SetString(dbThresholdKey.V, 16)
+	key.N, oks[1] = new(big.Int).SetString(dbThresholdKey.N, 16)
+	if !all(oks) {
+		return errors.New("not hexadecimal")
+	}
+	key.Vi = make([]*big.Int, len(dbThresholdKey.Vi))
+	var ok bool
+	for i, vi := range dbThresholdKey.Vi {
+		key.Vi[i], ok = new(big.Int).SetString(vi, 16)
+		if !ok {
+			return errors.New("not hexadecimal")
+		}
+
+	}
+	return nil
+}
+
+func (thresholdPublicKey *ThresholdPublicKey) GetBSON() (interface{}, error) {
+	r := new(dbThresholdKey)
+	r.FromThresholdPublicKey(thresholdPublicKey)
+	return r, nil
+}
+
+func (thresholdPublicKey *ThresholdPublicKey) SetBSON(raw bson.Raw) error {
+	r := new(dbThresholdKey)
+	if err := raw.Unmarshal(r); err != nil {
+		return err
+	}
+	return r.ToThresholdPublicKey(thresholdPublicKey)
+}
+
+func (this *PublicKey) GetBSON() (interface{}, error) {
+	m := make(map[string]string)
+	m["n"] = fmt.Sprintf("%x", this.N)
+	return m, nil
+}
+
+type dbPrivateKey struct {
+	N      string `bson:",omitempty"`
+	Lambda string `bson:",omitempty"`
+	Mu     string `bson:",omitempty"`
+}
+
+func (this *PrivateKey) GetBSON() (interface{}, error) {
+	m := make(map[string]string)
+
+	if this.N != nil {
+		m["n"] = fmt.Sprintf("%x", this.N)
+	}
+	if this.Lambda != nil {
+		m["lambda"] = fmt.Sprintf("%x", this.Lambda)
+	}
+	return m, nil
+}
+
+func (this *PrivateKey) SetBSON(raw bson.Raw) error {
+	var err error = nil
+	c := new(dbPrivateKey)
+	raw.Unmarshal(c)
+
+	if c.N != "" {
+		this.N, err = fromHex(c.N)
+		if err != nil {
+			return err
+		}
+	}
+
+	if c.Lambda != "" {
+		this.Lambda, err = fromHex(c.Lambda)
+		if err != nil {
+			return err
+		}
+	}
+
+	return err
+}
+
+type dbPartialDecryptionZKP struct {
+	Z                              string   `json:"z"`
+	E                              string   `json:"e"`
+	C                              string   `json:"c"`
+	V                              string   `json:"v"`
+	N                              string   `json:"n"`
+	Vi                             []string `json:"vi"`
+	Decryption                     string   `json:"decryption"`
+	Id                             int      `json:"id"`
+	TotalNumberOfDecryptionServers int      `json:"total_number_of_decryption_servers"`
+	Threshold                      int      `json:"threshold"`
+}
+
+func (this *dbPartialDecryptionZKP) FromPartialDecryptionZKP(pd *PartialDecryptionZKP) {
+	this.Id = pd.Id
+	this.TotalNumberOfDecryptionServers = pd.Key.TotalNumberOfDecryptionServers
+	this.Threshold = pd.Key.Threshold
+	this.Z = fmt.Sprintf("%x", pd.Z)
+	this.E = fmt.Sprintf("%x", pd.E)
+	this.N = fmt.Sprintf("%x", pd.Key.N)
+	this.C = fmt.Sprintf("%x", pd.C)
+	this.V = fmt.Sprintf("%x", pd.Key.V)
+	this.Decryption = fmt.Sprintf("%x", pd.Decryption)
+	this.Vi = make([]string, len(pd.Key.Vi))
+	for i, vi := range pd.Key.Vi {
+		this.Vi[i] = fmt.Sprintf("%x", vi)
+	}
+}
+
+func (this *dbPartialDecryptionZKP) ToPartialDecryptionZKP(pd *PartialDecryptionZKP) error {
+	pd.Key = new(paillier.ThresholdPublicKey)
+
+	var oks = make([]bool, 6)
+
+	pd.Id = this.Id
+	pd.Key.TotalNumberOfDecryptionServers = this.TotalNumberOfDecryptionServers
+	pd.Key.Threshold = this.Threshold
+	pd.Z, oks[0] = new(big.Int).SetString(this.Z, 16)
+	pd.E, oks[1] = new(big.Int).SetString(this.E, 16)
+	pd.C, oks[2] = new(big.Int).SetString(this.C, 16)
+	pd.Key.V, oks[3] = new(big.Int).SetString(this.V, 16)
+	pd.Key.N, oks[4] = new(big.Int).SetString(this.N, 16)
+	pd.Decryption, oks[5] = new(big.Int).SetString(this.Decryption, 16)
+
+	if !all(oks) {
+		fmt.Println(oks)
+		fmt.Println(this.E, "|", this.Z, "|", this.C, "|", this.V, "|", this.Decryption)
+		return errors.New("numbers not in hexadecimal format")
+	}
+
+	pd.Key.Vi = make([]*big.Int, len(this.Vi))
+	var ok bool
+	for i, vi := range this.Vi {
+		pd.Key.Vi[i], ok = new(big.Int).SetString(vi, 16)
+		if !ok {
+			return errors.New("numbers not in hexadecimal format")
+		}
+	}
+
+	return nil
+}
+
+func (this *PartialDecryptionZKP) MarshalJSON() ([]byte, error) {
+	db := new(dbPartialDecryptionZKP)
+	db.FromPartialDecryptionZKP(this)
+	return json.Marshal(db)
+}
+
+func (this *PartialDecryptionZKP) UnmarshalJSON(data []byte) error {
+	db := new(dbPartialDecryptionZKP)
+	if err := json.Unmarshal(data, db); err != nil {
+		return err
+	}
+	return db.ToPartialDecryptionZKP(this)
+}
+
+func (this *PartialDecryptionZKP) GetBSON() (interface{}, error) {
+	db := new(dbPartialDecryptionZKP)
+	db.FromPartialDecryptionZKP(this)
+	return db, nil
+}
+
+func (this *PartialDecryptionZKP) SetBSON(raw bson.Raw) error {
+	db := new(dbPartialDecryptionZKP)
+	if err := raw.Unmarshal(db); err != nil {
+		return err
+	}
+	return db.ToPartialDecryptionZKP(this)
+}
@@ -0,0 +1,134 @@
+package bson
+
+import (
+	"crypto/rand"
+	"encoding/json"
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/keep-network/paillier"
+	"gopkg.in/mgo.v2/bson"
+)
+
+func AssertBSONIsGood(object, dump interface{}, t *testing.T) {
+	data, err := bson.Marshal(object)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if err = bson.Unmarshal(data, dump); err != nil {
+		t.Error(err)
+		return
+	}
+	if !reflect.DeepEqual(object, dump) {
+		t.Errorf("Object: %v doesn't equal dump: %v", object, dump)
+	}
+}
+
+func AssertJSONIsGood(object, dump interface{}, t *testing.T) {
+	data, err := json.Marshal(object)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if err = json.Unmarshal(data, dump); err != nil {
+		t.Error(err)
+		return
+	}
+	if !reflect.DeepEqual(object, dump) {
+		t.Errorf("Object: %v doesn't equal dump: %v", object, dump)
+	}
+}
+
+func TestCypherGetBSON(t *testing.T) {
+	key := paillier.CreatePrivateKey(big.NewInt(101), big.NewInt(113))
+	cypherOriginal, err := key.Encrypt(big.NewInt(100), rand.Reader)
+
+	cypher := new(Cypher)
+	cypher.C = cypherOriginal.C
+
+	data, err := bson.Marshal(cypher)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	cypher2 := new(Cypher)
+	if err = bson.Unmarshal(data, cypher2); err != nil {
+		t.Error(err)
+		return
+	}
+	if !reflect.DeepEqual(cypher, cypher2) {
+		t.Errorf("%v not equal %v", cypher, cypher2)
+	}
+}
+
+func TestThresholdKeyBSON(t *testing.T) {
+	key := &ThresholdPublicKey{
+		PublicKey:                      paillier.PublicKey{b(9)},
+		TotalNumberOfDecryptionServers: 7,
+		Threshold:                      6,
+		V:                              b(3),
+		Vi:                             []*big.Int{b(2), b(34)},
+	}
+	AssertBSONIsGood(key, new(ThresholdPublicKey), t)
+}
+
+func TestSetPrivateKeyBson(t *testing.T) {
+	var key = new(PrivateKey)
+	var keyOriginal = paillier.CreatePrivateKey(big.NewInt(101), big.NewInt(113))
+
+	key.PublicKey = keyOriginal.PublicKey
+	key.Lambda = keyOriginal.Lambda
+
+	dump := new(PrivateKey)
+
+	AssertBSONIsGood(key, dump, t)
+}
+
+func TestGetBSONEmptyKey(t *testing.T) {
+	key := new(PrivateKey)
+	m, err := key.GetBSON()
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(make(map[string]string), m) {
+		t.Error(m)
+	}
+}
+
+func TestPartialDecryptionZKPJsonification(t *testing.T) {
+	pd := new(PartialDecryptionZKP)
+	pd.Key = new(paillier.ThresholdPublicKey)
+	pd.Key.Threshold = 98
+	pd.Key.TotalNumberOfDecryptionServers = 230
+	pd.Id = 1
+	pd.Key.Vi = []*big.Int{b(77), b(67)}
+	pd.Key.N = b(131)
+	pd.Key.V = b(101)
+	pd.Decryption = b(171)
+	pd.E = b(112)
+	pd.C = b(99)
+	pd.Key.N = b(345)
+	pd.Z = b(88)
+
+	AssertJSONIsGood(pd, new(PartialDecryptionZKP), t)
+}
+
+func TestPartialDecryptionZKPBSONification(t *testing.T) {
+	pd := new(PartialDecryptionZKP)
+	pd.Key = new(paillier.ThresholdPublicKey)
+	pd.Key.Threshold = 98
+	pd.Key.TotalNumberOfDecryptionServers = 230
+	pd.Id = 1
+	pd.Key.Vi = []*big.Int{b(77), b(67)} // vi is 67
+	pd.Key.N = b(131)
+	pd.Key.V = b(101)
+	pd.Decryption = b(171)
+	pd.E = b(112)
+	pd.C = b(99)
+	pd.Key.N = b(345)
+	pd.Z = b(88)
+
+	AssertBSONIsGood(pd, new(PartialDecryptionZKP), t)
+}
@@ -0,0 +1,29 @@
+package bson
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+)
+
+func fromHex(hex string) (*big.Int, error) {
+	n, err := new(big.Int).SetString(hex, 16)
+	if !err {
+		msg := fmt.Sprintf("Cannot convert %s to int as hexadecimal", hex)
+		return nil, errors.New(msg)
+	}
+	return n, nil
+}
+
+func all(oks []bool) bool {
+	for _, ok := range oks {
+		if !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func b(i int) *big.Int {
+	return big.NewInt(int64(i))
+}