From 5adb70bc7bd34d4a52f78636a592f255c13b8441 Mon Sep 17 00:00:00 2001 From: sachaservan Date: Sat, 18 Aug 2018 13:14:21 -0400 Subject: [PATCH] rename PrivateKey -> SecretKey --- bson/encoding_privatekey.go | 44 ++++++++++----------- bson/encoding_privatekey_test.go | 8 ++-- paillier.go | 10 ++--- paillier_test.go | 66 ++++++++++++++++---------------- thresholdkey.go | 18 ++++----- thresholdkey_generator.go | 14 +++---- thresholdkey_test.go | 14 +++---- 7 files changed, 87 insertions(+), 87 deletions(-) diff --git a/bson/encoding_privatekey.go b/bson/encoding_privatekey.go index f1cca88..b3357b5 100644 --- a/bson/encoding_privatekey.go +++ b/bson/encoding_privatekey.go @@ -7,65 +7,65 @@ import ( "gopkg.in/mgo.v2/bson" ) -type SerializablePrivateKey paillier.PrivateKey +type SerializableSecretKey paillier.SecretKey -// Serializes PrivateKey to BSON -func SerializePrivateKey(key *paillier.PrivateKey) ([]byte, error) { - return bson.Marshal(toSerializablePrivateKey(key)) +// Serializes SecretKey to BSON +func SerializeSecretKey(key *paillier.SecretKey) ([]byte, error) { + return bson.Marshal(toSerializableSecretKey(key)) } -// Deserializes BSON to PrivateKey -func DeserializePrivateKey(data []byte) (*paillier.PrivateKey, error) { - serializable := new(SerializablePrivateKey) +// Deserializes BSON to SecretKey +func DeserializeSecretKey(data []byte) (*paillier.SecretKey, error) { + serializable := new(SerializableSecretKey) if err := bson.Unmarshal(data, serializable); err != nil { return nil, err } - return toOriginalPrivateKey(serializable), nil + return toOriginalSecretKey(serializable), nil } -func toSerializablePrivateKey(key *paillier.PrivateKey) *SerializablePrivateKey { - serializable := SerializablePrivateKey(*key) +func toSerializableSecretKey(key *paillier.SecretKey) *SerializableSecretKey { + serializable := SerializableSecretKey(*key) return &serializable } -func toOriginalPrivateKey(serializable *SerializablePrivateKey) *paillier.PrivateKey { - original := paillier.PrivateKey(*serializable) +func toOriginalSecretKey(serializable *SerializableSecretKey) *paillier.SecretKey { + original := paillier.SecretKey(*serializable) return &original } -type dbPrivateKey struct { +type dbSecretKey struct { N string `bson:",omitempty"` Lambda string `bson:",omitempty"` Mu string `bson:",omitempty"` } -func (privateKey *SerializablePrivateKey) GetBSON() (interface{}, error) { +func (SecretKey *SerializableSecretKey) GetBSON() (interface{}, error) { m := make(map[string]string) - if privateKey.N != nil { - m["n"] = fmt.Sprintf("%x", privateKey.N) + if SecretKey.N != nil { + m["n"] = fmt.Sprintf("%x", SecretKey.N) } - if privateKey.Lambda != nil { - m["lambda"] = fmt.Sprintf("%x", privateKey.Lambda) + if SecretKey.Lambda != nil { + m["lambda"] = fmt.Sprintf("%x", SecretKey.Lambda) } return m, nil } -func (privateKey *SerializablePrivateKey) SetBSON(raw bson.Raw) error { +func (SecretKey *SerializableSecretKey) SetBSON(raw bson.Raw) error { var err error = nil - c := new(dbPrivateKey) + c := new(dbSecretKey) raw.Unmarshal(c) if c.N != "" { - privateKey.N, err = fromHex(c.N) + SecretKey.N, err = fromHex(c.N) if err != nil { return err } } if c.Lambda != "" { - privateKey.Lambda, err = fromHex(c.Lambda) + SecretKey.Lambda, err = fromHex(c.Lambda) if err != nil { return err } diff --git a/bson/encoding_privatekey_test.go b/bson/encoding_privatekey_test.go index 8870bcc..0194dad 100644 --- a/bson/encoding_privatekey_test.go +++ b/bson/encoding_privatekey_test.go @@ -7,20 +7,20 @@ import ( "github.com/keep-network/paillier" ) -func TestPrivateKeyBsonSerialization(t *testing.T) { - key := &paillier.PrivateKey{ +func TestSecretKeyBsonSerialization(t *testing.T) { + key := &paillier.SecretKey{ PublicKey: paillier.PublicKey{ N: (b(345)), }, Lambda: b(5), } - serialized, err := SerializePrivateKey(key) + serialized, err := SerializeSecretKey(key) if err != nil { t.Fatal(err) } - deserialized, err := DeserializePrivateKey(serialized) + deserialized, err := DeserializeSecretKey(serialized) if err != nil { t.Fatal(err) } diff --git a/paillier.go b/paillier.go index a7153e8..c73baf9 100644 --- a/paillier.go +++ b/paillier.go @@ -102,7 +102,7 @@ func (pk *PublicKey) Mul(cypher *Cypher, scalar *big.Int) *Cypher { } } -type PrivateKey struct { +type SecretKey struct { PublicKey Lambda *big.Int } @@ -115,7 +115,7 @@ type PrivateKey struct { // D(c) = [ ((c^lambda) mod N^2) - 1) / N ] lambda^-1 mod N // // See [KL 08] construction 11.32, page 414. -func (priv *PrivateKey) Decrypt(cypher *Cypher) (msg *big.Int) { +func (priv *SecretKey) Decrypt(cypher *Cypher) (msg *big.Int) { mu := new(big.Int).ModInverse(priv.Lambda, priv.N) tmp := new(big.Int).Exp(cypher.C, priv.Lambda, priv.GetNSquare()) msg = new(big.Int).Mod(new(big.Int).Mul(L(tmp, priv.N), mu), priv.N) @@ -143,7 +143,7 @@ func computePhi(p, q *big.Int) *big.Int { return new(big.Int).Mul(minusOne(p), minusOne(q)) } -// CreatePrivateKey generates a Paillier private key accepting two large prime +// CreateSecretKey generates a Paillier private key accepting two large prime // numbers of equal length or other such that gcd(pq, (p-1)(q-1)) = 1. // // Algorithm is based on approach described in [KL 08], construction 11.32, @@ -159,11 +159,11 @@ func computePhi(p, q *big.Int) *big.Int { // A Generalization of Paillier’s Public-Key System // with Applications to Electronic Voting // Aarhus University, Dept. of Computer Science, BRICS -func CreatePrivateKey(p, q *big.Int) *PrivateKey { +func CreateSecretKey(p, q *big.Int) *SecretKey { n := new(big.Int).Mul(p, q) lambda := computePhi(p, q) - return &PrivateKey{ + return &SecretKey{ PublicKey: PublicKey{ N: n, }, diff --git a/paillier_test.go b/paillier_test.go index 5df9256..42147d0 100644 --- a/paillier_test.go +++ b/paillier_test.go @@ -32,18 +32,18 @@ func TestComputePhi(t *testing.T) { } } -func TestCreatePrivateKey(t *testing.T) { +func TestCreateSecretKey(t *testing.T) { p := big.NewInt(463) q := big.NewInt(631) - privateKey := CreatePrivateKey(p, q) + SecretKey := CreateSecretKey(p, q) - if privateKey.N.Cmp(big.NewInt(292153)) != 0 { - t.Errorf("Unexpected N PublicKey value [%v]", privateKey.N) + if SecretKey.N.Cmp(big.NewInt(292153)) != 0 { + t.Errorf("Unexpected N PublicKey value [%v]", SecretKey.N) } - if privateKey.Lambda.Cmp(big.NewInt(291060)) != 0 { - t.Errorf("Unexpected Lambda Public key value [%v]", privateKey.Lambda) + if SecretKey.Lambda.Cmp(big.NewInt(291060)) != 0 { + t.Errorf("Unexpected Lambda Public key value [%v]", SecretKey.Lambda) } } @@ -51,14 +51,14 @@ func TestEncryptDecryptSmall(t *testing.T) { p := big.NewInt(13) q := big.NewInt(11) for i := 1; i < 10; i++ { - privateKey := CreatePrivateKey(p, q) + SecretKey := CreateSecretKey(p, q) initialValue := big.NewInt(100) - cypher, err := privateKey.Encrypt(initialValue, rand.Reader) + cypher, err := SecretKey.Encrypt(initialValue, rand.Reader) if err != nil { t.Error(err) } - returnedValue := privateKey.Decrypt(cypher) + returnedValue := SecretKey.Decrypt(cypher) if initialValue.Cmp(returnedValue) != 0 { t.Error("wrong decryption ", returnedValue, " is not ", initialValue) } @@ -70,7 +70,7 @@ func TestCheckPlaintextSpace(t *testing.T) { q := big.NewInt(11) // N = pq = 143 so the plaintext space is [0, 143) - privateKey := CreatePrivateKey(p, q) + SecretKey := CreateSecretKey(p, q) var tests = map[string]struct { plaintext *big.Int @@ -101,7 +101,7 @@ func TestCheckPlaintextSpace(t *testing.T) { for testName, test := range tests { t.Run(testName, func(t *testing.T) { - cypher, err := privateKey.Encrypt(test.plaintext, rand.Reader) + cypher, err := SecretKey.Encrypt(test.plaintext, rand.Reader) if !reflect.DeepEqual(err, test.expectedError) { t.Errorf( "Unexpected error\nExpected: %v\nActual: %v", @@ -111,7 +111,7 @@ func TestCheckPlaintextSpace(t *testing.T) { } if test.expectedError == nil { - decrypted := privateKey.Decrypt(cypher) + decrypted := SecretKey.Decrypt(cypher) if test.plaintext.Cmp(decrypted) != 0 { t.Errorf( "Unexpected decryption\nExpected: %v\nActual: %v", @@ -125,44 +125,44 @@ func TestCheckPlaintextSpace(t *testing.T) { } func TestAddCyphers(t *testing.T) { - privateKey := CreatePrivateKey(big.NewInt(17), big.NewInt(13)) + SecretKey := CreateSecretKey(big.NewInt(17), big.NewInt(13)) - cypher1, _ := privateKey.Encrypt(big.NewInt(5), rand.Reader) - cypher2, _ := privateKey.Encrypt(big.NewInt(6), rand.Reader) - cypher3, _ := privateKey.Encrypt(big.NewInt(7), rand.Reader) - cypher4, _ := privateKey.Encrypt(big.NewInt(8), rand.Reader) - cypher5 := privateKey.Add(cypher1, cypher2, cypher3, cypher4) + cypher1, _ := SecretKey.Encrypt(big.NewInt(5), rand.Reader) + cypher2, _ := SecretKey.Encrypt(big.NewInt(6), rand.Reader) + cypher3, _ := SecretKey.Encrypt(big.NewInt(7), rand.Reader) + cypher4, _ := SecretKey.Encrypt(big.NewInt(8), rand.Reader) + cypher5 := SecretKey.Add(cypher1, cypher2, cypher3, cypher4) - m := privateKey.Decrypt(cypher5) + m := SecretKey.Decrypt(cypher5) if m.Cmp(big.NewInt(26)) != 0 { t.Errorf("Unexpected decrypted value [%v]", m) } } func TestAddCypherWithSmallKeyModulus(t *testing.T) { - privateKey := CreatePrivateKey(big.NewInt(7), big.NewInt(5)) + SecretKey := CreateSecretKey(big.NewInt(7), big.NewInt(5)) - cypher1, _ := privateKey.Encrypt(big.NewInt(30), rand.Reader) - cypher2, _ := privateKey.Encrypt(big.NewInt(25), rand.Reader) - cypher3, _ := privateKey.Encrypt(big.NewInt(11), rand.Reader) - cypher4 := privateKey.Add(cypher1, cypher2, cypher3) + cypher1, _ := SecretKey.Encrypt(big.NewInt(30), rand.Reader) + cypher2, _ := SecretKey.Encrypt(big.NewInt(25), rand.Reader) + cypher3, _ := SecretKey.Encrypt(big.NewInt(11), rand.Reader) + cypher4 := SecretKey.Add(cypher1, cypher2, cypher3) - m := privateKey.Decrypt(cypher4) + m := SecretKey.Decrypt(cypher4) if m.Cmp(big.NewInt(31)) != 0 { t.Errorf("Unexpected decrypted value [%v]", m) } } func TestMulCypher(t *testing.T) { - privateKey := CreatePrivateKey(big.NewInt(17), big.NewInt(13)) + SecretKey := CreateSecretKey(big.NewInt(17), big.NewInt(13)) - cypher, err := privateKey.Encrypt(big.NewInt(3), rand.Reader) + cypher, err := SecretKey.Encrypt(big.NewInt(3), rand.Reader) if err != nil { t.Fatal(err) } - cypherMultiple := privateKey.Mul(cypher, big.NewInt(7)) - multiple := privateKey.Decrypt(cypherMultiple) + cypherMultiple := SecretKey.Mul(cypher, big.NewInt(7)) + multiple := SecretKey.Decrypt(cypherMultiple) // 3 * 7 = 21 if multiple.Cmp(big.NewInt(21)) != 0 { @@ -171,15 +171,15 @@ func TestMulCypher(t *testing.T) { } func TestMulCypherWithSmallKeyModulus(t *testing.T) { - privateKey := CreatePrivateKey(big.NewInt(7), big.NewInt(5)) + SecretKey := CreateSecretKey(big.NewInt(7), big.NewInt(5)) - cypher, err := privateKey.Encrypt(big.NewInt(30), rand.Reader) + cypher, err := SecretKey.Encrypt(big.NewInt(30), rand.Reader) if err != nil { t.Fatal(err) } - cypherMultiple := privateKey.Mul(cypher, big.NewInt(93)) - multiple := privateKey.Decrypt(cypherMultiple) + cypherMultiple := SecretKey.Mul(cypher, big.NewInt(93)) + multiple := SecretKey.Decrypt(cypherMultiple) // (30*93) mod (7*5) = 25 if multiple.Cmp(big.NewInt(25)) != 0 { diff --git a/thresholdkey.go b/thresholdkey.go index 83f8ac6..c2cb7aa 100644 --- a/thresholdkey.go +++ b/thresholdkey.go @@ -175,14 +175,14 @@ func (tk *ThresholdPublicKey) VerifyDecryption(encryptedMessage, decryptedMessag // for the given decryption server. // `Id` is the unique identifier of a decryption server and `Share` is a secret // share generated from hiding polynomial and is used for a partial share decryption. -type ThresholdPrivateKey struct { +type ThresholdSecretKey struct { ThresholdPublicKey Id int Share *big.Int } // Decrypts the cypher text and returns the partial decryption -func (tpk *ThresholdPrivateKey) Decrypt(c *big.Int) *PartialDecryption { +func (tpk *ThresholdSecretKey) Decrypt(c *big.Int) *PartialDecryption { ret := new(PartialDecryption) ret.Id = tpk.Id exp := new(big.Int).Mul(tpk.Share, new(big.Int).Mul(TWO, tpk.delta())) @@ -191,7 +191,7 @@ func (tpk *ThresholdPrivateKey) Decrypt(c *big.Int) *PartialDecryption { return ret } -func (tpk *ThresholdPrivateKey) copyVi() []*big.Int { +func (tpk *ThresholdSecretKey) copyVi() []*big.Int { ret := make([]*big.Int, len(tpk.Vi)) for i, vi := range tpk.Vi { ret[i] = new(big.Int).Add(vi, big.NewInt(0)) @@ -199,7 +199,7 @@ func (tpk *ThresholdPrivateKey) copyVi() []*big.Int { return ret } -func (tpk *ThresholdPrivateKey) getThresholdKey() *ThresholdPublicKey { +func (tpk *ThresholdSecretKey) getThresholdKey() *ThresholdPublicKey { ret := new(ThresholdPublicKey) ret.Threshold = tpk.Threshold ret.TotalNumberOfDecryptionServers = tpk.TotalNumberOfDecryptionServers @@ -209,13 +209,13 @@ func (tpk *ThresholdPrivateKey) getThresholdKey() *ThresholdPublicKey { return ret } -func (tpk *ThresholdPrivateKey) computeZ(r, e *big.Int) *big.Int { +func (tpk *ThresholdSecretKey) computeZ(r, e *big.Int) *big.Int { tmp := new(big.Int).Mul(e, tpk.delta()) tmp = new(big.Int).Mul(tmp, tpk.Share) return new(big.Int).Add(r, tmp) } -func (tpk *ThresholdPrivateKey) computeHash(a, b, c4, ci2 *big.Int) *big.Int { +func (tpk *ThresholdSecretKey) computeHash(a, b, c4, ci2 *big.Int) *big.Int { hash := sha256.New() hash.Write(a.Bytes()) hash.Write(b.Bytes()) @@ -224,7 +224,7 @@ func (tpk *ThresholdPrivateKey) computeHash(a, b, c4, ci2 *big.Int) *big.Int { return new(big.Int).SetBytes(hash.Sum([]byte{})) } -func (tpk *ThresholdPrivateKey) DecryptAndProduceZNP(c *big.Int, random io.Reader) (*PartialDecryptionZKP, error) { +func (tpk *ThresholdSecretKey) DecryptAndProduceZNP(c *big.Int, random io.Reader) (*PartialDecryptionZKP, error) { pd := new(PartialDecryptionZKP) pd.Key = tpk.getThresholdKey() pd.C = c @@ -255,7 +255,7 @@ func (tpk *ThresholdPrivateKey) DecryptAndProduceZNP(c *big.Int, random io.Reade // Verifies if the partial decryption key is well formed. If well formed, // the method return nil else an explicative error is returned. -func (tpk *ThresholdPrivateKey) Validate(random io.Reader) error { +func (tpk *ThresholdSecretKey) Validate(random io.Reader) error { m, err := rand.Int(random, tpk.N) if err != nil { return err @@ -281,7 +281,7 @@ type PartialDecryption struct { // A non-interactive ZKP based on the Fiat–Shamir heuristic. This algorithm // proves that the decryption server indeed raised secret to his secret exponent -// (`ThresholdPrivateKey.Share`) by comparison with the public verification key +// (`ThresholdSecretKey.Share`) by comparison with the public verification key // (`ThresholdKey.Vi`). Recall that v_i = v^(delta s_i). // // The Fiat-Shamir is a non-interactive proof of knowledge heuristic. diff --git a/thresholdkey_generator.go b/thresholdkey_generator.go index f7ef687..dec8b98 100644 --- a/thresholdkey_generator.go +++ b/thresholdkey_generator.go @@ -240,8 +240,8 @@ func (tkg *ThresholdKeyGenerator) createViArray(shares []*big.Int) (viArray []*b return viArray } -func (tkg *ThresholdKeyGenerator) createPrivateKey(i int, share *big.Int, viArray []*big.Int) *ThresholdPrivateKey { - ret := new(ThresholdPrivateKey) +func (tkg *ThresholdKeyGenerator) createSecretKey(i int, share *big.Int, viArray []*big.Int) *ThresholdSecretKey { + ret := new(ThresholdSecretKey) ret.N = tkg.n ret.V = tkg.v @@ -253,22 +253,22 @@ func (tkg *ThresholdKeyGenerator) createPrivateKey(i int, share *big.Int, viArra return ret } -func (tkg *ThresholdKeyGenerator) createPrivateKeys() []*ThresholdPrivateKey { +func (tkg *ThresholdKeyGenerator) createSecretKeys() []*ThresholdSecretKey { shares := tkg.createShares() viArray := tkg.createViArray(shares) - ret := make([]*ThresholdPrivateKey, tkg.TotalNumberOfDecryptionServers) + ret := make([]*ThresholdSecretKey, tkg.TotalNumberOfDecryptionServers) for i := 0; i < tkg.TotalNumberOfDecryptionServers; i++ { - ret[i] = tkg.createPrivateKey(i, shares[i], viArray) + ret[i] = tkg.createSecretKey(i, shares[i], viArray) } return ret } -func (tkg *ThresholdKeyGenerator) Generate() ([]*ThresholdPrivateKey, error) { +func (tkg *ThresholdKeyGenerator) Generate() ([]*ThresholdSecretKey, error) { if err := tkg.initNumerialValues(); err != nil { return nil, err } if err := tkg.generateHidingPolynomial(); err != nil { return nil, err } - return tkg.createPrivateKeys(), nil + return tkg.createSecretKeys(), nil } diff --git a/thresholdkey_test.go b/thresholdkey_test.go index ce7525e..c483ebf 100644 --- a/thresholdkey_test.go +++ b/thresholdkey_test.go @@ -7,7 +7,7 @@ import ( "testing" ) -func getThresholdPrivateKey() *ThresholdPrivateKey { +func getThresholdSecretKey() *ThresholdSecretKey { tkh, err := GetThresholdKeyGenerator(32, 10, 6, rand.Reader) if err != nil { panic(err) @@ -55,7 +55,7 @@ func TestCombineSharesConstant(t *testing.T) { } func TestDecrypt(t *testing.T) { - key := new(ThresholdPrivateKey) + key := new(ThresholdSecretKey) key.TotalNumberOfDecryptionServers = 10 key.N = b(101 * 103) key.Share = b(862) @@ -73,7 +73,7 @@ func TestDecrypt(t *testing.T) { } func TestCopyVi(t *testing.T) { - key := new(ThresholdPrivateKey) + key := new(ThresholdSecretKey) key.Vi = []*big.Int{b(34), b(2), b(29)} vi := key.copyVi() if !reflect.DeepEqual(vi, key.Vi) { @@ -86,7 +86,7 @@ func TestCopyVi(t *testing.T) { } func TestEncryptWithThresholdKey(t *testing.T) { - pd := getThresholdPrivateKey() + pd := getThresholdSecretKey() _, err := pd.Encrypt(big.NewInt(876), rand.Reader) if err != nil { t.Fail() @@ -94,7 +94,7 @@ func TestEncryptWithThresholdKey(t *testing.T) { } func TestDecryptWithThresholdKey(t *testing.T) { - pd := getThresholdPrivateKey() + pd := getThresholdSecretKey() c, err := pd.Encrypt(big.NewInt(876), rand.Reader) if err != nil { t.Fail() @@ -131,7 +131,7 @@ func TestVerifyPart2(t *testing.T) { } func TestDecryptAndProduceZNP(t *testing.T) { - pd := getThresholdPrivateKey() + pd := getThresholdSecretKey() c, err := pd.Encrypt(big.NewInt(876), rand.Reader) if err != nil { t.Error(err) @@ -283,7 +283,7 @@ func TestDecryption(t *testing.T) { } func TestValidate(t *testing.T) { - pk := getThresholdPrivateKey() + pk := getThresholdSecretKey() if err := pk.Validate(rand.Reader); err != nil { t.Error(err) }