didier/paillier
1
0 Fork 0
Code Issues 1 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Fix spelling/naming issues, slightly more robust testing of encryption and decryption. #12

Closed
sachaservan wants to merge 7 commits from master into master
pull from: master
merge into: didier:master
Conversation 7 Commits 7 Files Changed 9
+184 -161
9 changed files with 184 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

bson/encoding_cypher.go
+14 -14
View File
@@ -9,15 +9,15 @@ import (
"gopkg.in/mgo.v2/bson" "gopkg.in/mgo.v2/bson"
) )
type SerializableCypher paillier.Cypher type SerializableCypher paillier.Ciphertext
// Serializes Cypher to BSON // Serializes Ciphertext to BSON
func SerializeCypher(cypher *paillier.Cypher) ([]byte, error) { func SerializeCypher(ct *paillier.Ciphertext) ([]byte, error) {
return bson.Marshal(toSerializableCypher(cypher)) return bson.Marshal(toSerializableCypher(ct))
} }
// Deserializes BSON to Cypher // Deserializes BSON to Ciphertext
func DeserializeCypher(data []byte) (*paillier.Cypher, error) { func DeserializeCypher(data []byte) (*paillier.Ciphertext, error) {
serializable := new(SerializableCypher) serializable := new(SerializableCypher)
if err := bson.Unmarshal(data, serializable); err != nil { if err := bson.Unmarshal(data, serializable); err != nil {
return nil, err return nil, err
@@ -26,13 +26,13 @@ func DeserializeCypher(data []byte) (*paillier.Cypher, error) {
return toOriginalCypher(serializable), nil return toOriginalCypher(serializable), nil
} }
func toSerializableCypher(cypher *paillier.Cypher) *SerializableCypher { func toSerializableCypher(ct *paillier.Ciphertext) *SerializableCypher {
serializable := SerializableCypher(*cypher) serializable := SerializableCypher(*ct)
return &serializable return &serializable
} }
func toOriginalCypher(serializable *SerializableCypher) *paillier.Cypher { func toOriginalCypher(serializable *SerializableCypher) *paillier.Ciphertext {
original := paillier.Cypher(*serializable) original := paillier.Ciphertext(*serializable)
return &original return &original
} }
@@ -40,17 +40,17 @@ type dbCypher struct {
C string C string
} }
func (cypher *SerializableCypher) GetBSON() (interface{}, error) { func (ct *SerializableCypher) GetBSON() (interface{}, error) {
return &dbCypher{fmt.Sprintf("%x", cypher.C)}, nil return &dbCypher{fmt.Sprintf("%x", ct.C)}, nil
} }
func (cypher *SerializableCypher) SetBSON(raw bson.Raw) error { func (ct *SerializableCypher) SetBSON(raw bson.Raw) error {
c := dbCypher{} c := dbCypher{}
if err := raw.Unmarshal(&c); err != nil { if err := raw.Unmarshal(&c); err != nil {
return err return err
} }
var ok bool var ok bool
cypher.C, ok = new(big.Int).SetString(c.C, 16) ct.C, ok = new(big.Int).SetString(c.C, 16)
if !ok { if !ok {
return errors.New("big int not in hexadecimal format") return errors.New("big int not in hexadecimal format")
} }
bson/encoding_cypher_test.go
+4 -4
View File
@@ -8,11 +8,11 @@ import (
) )
func TestCypherBsonSerialization(t *testing.T) { func TestCypherBsonSerialization(t *testing.T) {
cypher := &paillier.Cypher{ ct := &paillier.Ciphertext{
C: b(5), C: b(5),
} }
serialized, err := SerializeCypher(cypher) serialized, err := SerializeCypher(ct)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@@ -22,11 +22,11 @@ func TestCypherBsonSerialization(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
if !reflect.DeepEqual(cypher, deserialized) { if !reflect.DeepEqual(ct, deserialized) {
t.Errorf( t.Errorf(
"Unexpected serialization result\nActual: %v\nExpected: %v\n", "Unexpected serialization result\nActual: %v\nExpected: %v\n",
deserialized, deserialized,
cypher, ct,
) )
} }
} }
bson/encoding_privatekey.go
+22 -22
View File
@@ -7,65 +7,65 @@ import (
"gopkg.in/mgo.v2/bson" "gopkg.in/mgo.v2/bson"
) )
type SerializablePrivateKey paillier.PrivateKey type SerializableSecretKey paillier.SecretKey
// Serializes PrivateKey to BSON // Serializes SecretKey to BSON
func SerializePrivateKey(key *paillier.PrivateKey) ([]byte, error) { func SerializeSecretKey(key *paillier.SecretKey) ([]byte, error) {
return bson.Marshal(toSerializablePrivateKey(key)) return bson.Marshal(toSerializableSecretKey(key))
} }
// Deserializes BSON to PrivateKey // Deserializes BSON to SecretKey
func DeserializePrivateKey(data []byte) (*paillier.PrivateKey, error) { func DeserializeSecretKey(data []byte) (*paillier.SecretKey, error) {
serializable := new(SerializablePrivateKey) serializable := new(SerializableSecretKey)
if err := bson.Unmarshal(data, serializable); err != nil { if err := bson.Unmarshal(data, serializable); err != nil {
return nil, err return nil, err
} }
return toOriginalPrivateKey(serializable), nil return toOriginalSecretKey(serializable), nil
} }
func toSerializablePrivateKey(key *paillier.PrivateKey) *SerializablePrivateKey { func toSerializableSecretKey(key *paillier.SecretKey) *SerializableSecretKey {
serializable := SerializablePrivateKey(*key) serializable := SerializableSecretKey(*key)
return &serializable return &serializable
} }
func toOriginalPrivateKey(serializable *SerializablePrivateKey) *paillier.PrivateKey { func toOriginalSecretKey(serializable *SerializableSecretKey) *paillier.SecretKey {
original := paillier.PrivateKey(*serializable) original := paillier.SecretKey(*serializable)
return &original return &original
} }
type dbPrivateKey struct { type dbSecretKey struct {
N string `bson:",omitempty"` N string `bson:",omitempty"`
Lambda string `bson:",omitempty"` Lambda string `bson:",omitempty"`
Mu string `bson:",omitempty"` Mu string `bson:",omitempty"`
} }
func (privateKey *SerializablePrivateKey) GetBSON() (interface{}, error) { func (SecretKey *SerializableSecretKey) GetBSON() (interface{}, error) {
m := make(map[string]string) m := make(map[string]string)
if privateKey.N != nil { if SecretKey.N != nil {
m["n"] = fmt.Sprintf("%x", privateKey.N) m["n"] = fmt.Sprintf("%x", SecretKey.N)
} }
if privateKey.Lambda != nil { if SecretKey.Lambda != nil {
m["lambda"] = fmt.Sprintf("%x", privateKey.Lambda) m["lambda"] = fmt.Sprintf("%x", SecretKey.Lambda)
} }
return m, nil return m, nil
} }
func (privateKey *SerializablePrivateKey) SetBSON(raw bson.Raw) error { func (SecretKey *SerializableSecretKey) SetBSON(raw bson.Raw) error {
var err error = nil var err error = nil
c := new(dbPrivateKey) c := new(dbSecretKey)
raw.Unmarshal(c) raw.Unmarshal(c)
if c.N != "" { if c.N != "" {
privateKey.N, err = fromHex(c.N) SecretKey.N, err = fromHex(c.N)
if err != nil { if err != nil {
return err return err
} }
} }
if c.Lambda != "" { if c.Lambda != "" {
privateKey.Lambda, err = fromHex(c.Lambda) SecretKey.Lambda, err = fromHex(c.Lambda)
if err != nil { if err != nil {
return err return err
} }
bson/encoding_privatekey_test.go
+4 -4
View File
@@ -7,20 +7,20 @@ import (
"github.com/keep-network/paillier" "github.com/keep-network/paillier"
) )
func TestPrivateKeyBsonSerialization(t *testing.T) { func TestSecretKeyBsonSerialization(t *testing.T) {
key := &paillier.PrivateKey{ key := &paillier.SecretKey{
PublicKey: paillier.PublicKey{ PublicKey: paillier.PublicKey{
N: (b(345)), N: (b(345)),
}, },
Lambda: b(5), Lambda: b(5),
} }
serialized, err := SerializePrivateKey(key) serialized, err := SerializeSecretKey(key)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
deserialized, err := DeserializePrivateKey(serialized) deserialized, err := DeserializeSecretKey(serialized)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
paillier.go
+31 -29
View File
@@ -8,13 +8,14 @@ import (
type PublicKey struct { type PublicKey struct {
N *big.Int N *big.Int
G *big.Int
} }
func (pk *PublicKey) GetNSquare() *big.Int { func (pk *PublicKey) GetNSquare() *big.Int {
return new(big.Int).Mul(pk.N, pk.N) return new(big.Int).Mul(pk.N, pk.N)
} }
// EncryptWithR encrypts a plaintext into a cypher one with random `r` specified // EncryptWithR encrypts a plaintext into a ct one with random `r` specified
// in the argument. The plain text must be smaller that N and bigger than or // in the argument. The plain text must be smaller that N and bigger than or
// equal zero. `r` is the randomness used to encrypt the plaintext. `r` must be // equal zero. `r` is the randomness used to encrypt the plaintext. `r` must be
// a random element from a multiplicative group of integers modulo N. // a random element from a multiplicative group of integers modulo N.
@@ -27,7 +28,7 @@ func (pk *PublicKey) GetNSquare() *big.Int {
// E(m, r) = [(1 + N) r^N] mod N^2 // E(m, r) = [(1 + N) r^N] mod N^2
// //
// See [KL 08] construction 11.32, page 414. // See [KL 08] construction 11.32, page 414.
func (pk *PublicKey) EncryptWithR(m *big.Int, r *big.Int) (*Cypher, error) { func (pk *PublicKey) EncryptWithR(m *big.Int, r *big.Int) (*Ciphertext, error) {
if m.Cmp(ZERO) == -1 || m.Cmp(pk.N) != -1 { // m < 0 || m >= N ? if m.Cmp(ZERO) == -1 || m.Cmp(pk.N) != -1 { // m < 0 || m >= N ?
return nil, fmt.Errorf( return nil, fmt.Errorf(
"%v is out of allowed plaintext space [0, %v)", "%v is out of allowed plaintext space [0, %v)",
@@ -41,13 +42,12 @@ func (pk *PublicKey) EncryptWithR(m *big.Int, r *big.Int) (*Cypher, error) {
// g is _always_ equal n+1 // g is _always_ equal n+1
// Threshold encryption is safe only for g=n+1 choice. // Threshold encryption is safe only for g=n+1 choice.
// See [DJN 10], section 5.1 // See [DJN 10], section 5.1
g := new(big.Int).Add(pk.N, big.NewInt(1)) gm := new(big.Int).Exp(pk.G, m, nSquare)
gm := new(big.Int).Exp(g, m, nSquare)
rn := new(big.Int).Exp(r, pk.N, nSquare) rn := new(big.Int).Exp(r, pk.N, nSquare)
return &Cypher{new(big.Int).Mod(new(big.Int).Mul(rn, gm), nSquare)}, nil return &Ciphertext{new(big.Int).Mod(new(big.Int).Mul(rn, gm), nSquare)}, nil
} }
// Encrypt a plaintext into a cypher one. The plain text must be smaller that // Encrypt a plaintext into a ct one. The plain text must be smaller that
// N and bigger than or equal zero. random is usually rand.Reader from the // N and bigger than or equal zero. random is usually rand.Reader from the
// package crypto/rand. // package crypto/rand.
// //
@@ -57,7 +57,7 @@ func (pk *PublicKey) EncryptWithR(m *big.Int, r *big.Int) (*Cypher, error) {
// See [KL 08] construction 11.32, page 414. // See [KL 08] construction 11.32, page 414.
// //
// Returns an error if an error has be returned by io.Reader. // Returns an error if an error has be returned by io.Reader.
func (pk *PublicKey) Encrypt(m *big.Int, random io.Reader) (*Cypher, error) { func (pk *PublicKey) Encrypt(m *big.Int, random io.Reader) (*Ciphertext, error) {
r, err := GetRandomNumberInMultiplicativeGroup(pk.N, random) r, err := GetRandomNumberInMultiplicativeGroup(pk.N, random)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -66,7 +66,7 @@ func (pk *PublicKey) Encrypt(m *big.Int, random io.Reader) (*Cypher, error) {
return pk.EncryptWithR(m, r) return pk.EncryptWithR(m, r)
} }
// Add takes an arbitrary number of cyphertexts and returns one that encodes // Add takes an arbitrary number of ciphertexts and returns one that encodes
// their sum. // their sum.
// //
// It's possible because Paillier is a homomorphic encryption scheme, where // It's possible because Paillier is a homomorphic encryption scheme, where
@@ -74,59 +74,59 @@ func (pk *PublicKey) Encrypt(m *big.Int, random io.Reader) (*Cypher, error) {
// plaintexts: // plaintexts:
// //
// D( (E(m1) * E(m2) mod n^2) ) = m1 + m2 mod n // D( (E(m1) * E(m2) mod n^2) ) = m1 + m2 mod n
func (pk *PublicKey) Add(cypher ...*Cypher) *Cypher { func (pk *PublicKey) Add(ct ...*Ciphertext) *Ciphertext {
accumulator := big.NewInt(1) accumulator := big.NewInt(1)
for _, c := range cypher { for _, c := range ct {
accumulator = new(big.Int).Mod( accumulator = new(big.Int).Mod(
new(big.Int).Mul(accumulator, c.C), new(big.Int).Mul(accumulator, c.C),
pk.GetNSquare(), pk.GetNSquare(),
) )
} }
return &Cypher{ return &Ciphertext{
C: accumulator, C: accumulator,
} }
} }
// Mul returns a product of `cypher` and `scalar` without decrypting `cypher`. // Mul returns a product of `ct` and `scalar` without decrypting `ct`.
// //
// It's possible because Paillier is a homomorphic encryption scheme, where // It's possible because Paillier is a homomorphic encryption scheme, where
// an encrypted plaintext `m` raised to an integer `k` will decrypt to the // an encrypted plaintext `m` raised to an integer `k` will decrypt to the
// product of the plaintext `m` and `k`: // product of the plaintext `m` and `k`:
// //
// D( E(m)^k mod N^2 ) = km mod N // D( E(m)^k mod N^2 ) = km mod N
func (pk *PublicKey) Mul(cypher *Cypher, scalar *big.Int) *Cypher { func (pk *PublicKey) Mul(ct *Ciphertext, scalar *big.Int) *Ciphertext {
return &Cypher{ return &Ciphertext{
C: new(big.Int).Exp(cypher.C, scalar, pk.GetNSquare()), C: new(big.Int).Exp(ct.C, scalar, pk.GetNSquare()),
} }
} }
type PrivateKey struct { type SecretKey struct {
PublicKey PublicKey
Lambda *big.Int Lambda *big.Int
} }
// Decodes ciphertext into a plaintext message. // Decodes ciphertext into a plaintext message.
// //
// c - cyphertext to decrypt // c - ciphertext to decrypt
// N, lambda - key attributes // N, lambda - key attributes
// //
// D(c) = [ ((c^lambda) mod N^2) - 1) / N ] lambda^-1 mod N // D(c) = [ ((c^lambda)*mu mod N^2) - 1) / N ] lambda^-1 mod N
// //
// See [KL 08] construction 11.32, page 414. // See [KL 08] construction 11.32, page 414.
func (priv *PrivateKey) Decrypt(cypher *Cypher) (msg *big.Int) { func (sk *SecretKey) Decrypt(ct *Ciphertext) *big.Int {
mu := new(big.Int).ModInverse(priv.Lambda, priv.N) mu := new(big.Int).ModInverse(sk.Lambda, sk.N)
tmp := new(big.Int).Exp(cypher.C, priv.Lambda, priv.GetNSquare()) tmp := new(big.Int).Exp(ct.C, sk.Lambda, sk.GetNSquare())
msg = new(big.Int).Mod(new(big.Int).Mul(L(tmp, priv.N), mu), priv.N) m := new(big.Int).Mod(new(big.Int).Mul(L(tmp, sk.N), mu), sk.N)
return return m
} }
type Cypher struct { type Ciphertext struct {
C *big.Int C *big.Int
} }
func (this *Cypher) String() string { func (this *Ciphertext) String() string {
return fmt.Sprintf("%x", this.C) return fmt.Sprintf("%x", this.C)
} }
@@ -143,12 +143,12 @@ func computePhi(p, q *big.Int) *big.Int {
return new(big.Int).Mul(minusOne(p), minusOne(q)) return new(big.Int).Mul(minusOne(p), minusOne(q))
} }
// CreatePrivateKey generates a Paillier private key accepting two large prime // CreateSecretKey generates a Paillier skate key accepting two large prime
// numbers of equal length or other such that gcd(pq, (p-1)(q-1)) = 1. // 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, // Algorithm is based on approach described in [KL 08], construction 11.32,
// page 414 which is compatible with one described in [DJN 10], section 3.2 // page 414 which is compatible with one described in [DJN 10], section 3.2
// except that instead of generating Lambda private key component from LCM // except that instead of generating Lambda skate key component from LCM
// of p and q we use Euler's totient function as suggested in [KL 08]. // of p and q we use Euler's totient function as suggested in [KL 08].
// //
// [KL 08]: Jonathan Katz, Yehuda Lindell, (2008) // [KL 08]: Jonathan Katz, Yehuda Lindell, (2008)
@@ -159,13 +159,15 @@ func computePhi(p, q *big.Int) *big.Int {
// A Generalization of Paillier’s Public-Key System // A Generalization of Paillier’s Public-Key System
// with Applications to Electronic Voting // with Applications to Electronic Voting
// Aarhus University, Dept. of Computer Science, BRICS // 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) n := new(big.Int).Mul(p, q)
lambda := computePhi(p, q) lambda := computePhi(p, q)
g := new(big.Int).Add(n, big.NewInt(1))
nkuba commented 2018-08-22 09:32:27 -04:00 (Migrated from github.com)
Review
Copy link
Copy source

Paillier is an asymmetric cryptographic algorithm so the PrivateKey is 100% fine for this, there is no need to change it.

Paillier is an asymmetric cryptographic algorithm so the `PrivateKey` is 100% fine for this, there is no need to change it.
return &PrivateKey{ return &SecretKey{
PublicKey: PublicKey{ PublicKey: PublicKey{
N: n, N: n,
G: g,
}, },
Lambda: lambda, Lambda: lambda,
} }
paillier_test.go
+60 -40
View File
@@ -32,33 +32,33 @@ func TestComputePhi(t *testing.T) {
} }
} }
func TestCreatePrivateKey(t *testing.T) { func TestCreateSecretKey(t *testing.T) {
p := big.NewInt(463) p := big.NewInt(463)
q := big.NewInt(631) q := big.NewInt(631)
privateKey := CreatePrivateKey(p, q) sk := CreateSecretKey(p, q)
if privateKey.N.Cmp(big.NewInt(292153)) != 0 { if sk.N.Cmp(big.NewInt(292153)) != 0 {
t.Errorf("Unexpected N PublicKey value [%v]", privateKey.N) t.Errorf("Unexpected N PublicKey value [%v]", sk.N)
} }
if privateKey.Lambda.Cmp(big.NewInt(291060)) != 0 { if sk.Lambda.Cmp(big.NewInt(291060)) != 0 {
t.Errorf("Unexpected Lambda Public key value [%v]", privateKey.Lambda) t.Errorf("Unexpected Lambda Public key value [%v]", sk.Lambda)
} }
} }
func TestEncryptDecryptSmall(t *testing.T) { func TestEncryptDecryptSmall(t *testing.T) {
p := big.NewInt(13) for i := 1; i < 100; i++ {
q := big.NewInt(11)
for i := 1; i < 10; i++ { p, q := GenKeyPrimes(10)
privateKey := CreatePrivateKey(p, q) sk := CreateSecretKey(p, q)
initialValue := big.NewInt(100) initialValue := big.NewInt(100)
cypher, err := privateKey.Encrypt(initialValue, rand.Reader) ct, err := sk.Encrypt(initialValue, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
returnedValue := privateKey.Decrypt(cypher) returnedValue := sk.Decrypt(ct)
if initialValue.Cmp(returnedValue) != 0 { if initialValue.Cmp(returnedValue) != 0 {
t.Error("wrong decryption ", returnedValue, " is not ", initialValue) t.Error("wrong decryption ", returnedValue, " is not ", initialValue)
} }
@@ -70,7 +70,7 @@ func TestCheckPlaintextSpace(t *testing.T) {
q := big.NewInt(11) q := big.NewInt(11)
// N = pq = 143 so the plaintext space is [0, 143) // N = pq = 143 so the plaintext space is [0, 143)
privateKey := CreatePrivateKey(p, q) sk := CreateSecretKey(p, q)
var tests = map[string]struct { var tests = map[string]struct {
plaintext *big.Int plaintext *big.Int
@@ -101,7 +101,7 @@ func TestCheckPlaintextSpace(t *testing.T) {
for testName, test := range tests { for testName, test := range tests {
t.Run(testName, func(t *testing.T) { t.Run(testName, func(t *testing.T) {
cypher, err := privateKey.Encrypt(test.plaintext, rand.Reader) ct, err := sk.Encrypt(test.plaintext, rand.Reader)
if !reflect.DeepEqual(err, test.expectedError) { if !reflect.DeepEqual(err, test.expectedError) {
t.Errorf( t.Errorf(
"Unexpected error\nExpected: %v\nActual: %v", "Unexpected error\nExpected: %v\nActual: %v",
@@ -111,7 +111,7 @@ func TestCheckPlaintextSpace(t *testing.T) {
} }
if test.expectedError == nil { if test.expectedError == nil {
decrypted := privateKey.Decrypt(cypher) decrypted := sk.Decrypt(ct)
if test.plaintext.Cmp(decrypted) != 0 { if test.plaintext.Cmp(decrypted) != 0 {
t.Errorf( t.Errorf(
"Unexpected decryption\nExpected: %v\nActual: %v", "Unexpected decryption\nExpected: %v\nActual: %v",
@@ -124,45 +124,47 @@ func TestCheckPlaintextSpace(t *testing.T) {
} }
} }
func TestAddCyphers(t *testing.T) { func TestAddCiphertexts(t *testing.T) {
privateKey := CreatePrivateKey(big.NewInt(17), big.NewInt(13)) p, q := GenKeyPrimes(10)
sk := CreateSecretKey(p, q)
cypher1, _ := privateKey.Encrypt(big.NewInt(5), rand.Reader) ct1, _ := sk.Encrypt(big.NewInt(5), rand.Reader)
cypher2, _ := privateKey.Encrypt(big.NewInt(6), rand.Reader) ct2, _ := sk.Encrypt(big.NewInt(6), rand.Reader)
cypher3, _ := privateKey.Encrypt(big.NewInt(7), rand.Reader) ct3, _ := sk.Encrypt(big.NewInt(7), rand.Reader)
cypher4, _ := privateKey.Encrypt(big.NewInt(8), rand.Reader) ct4, _ := sk.Encrypt(big.NewInt(8), rand.Reader)
cypher5 := privateKey.Add(cypher1, cypher2, cypher3, cypher4) ct5 := sk.Add(ct1, ct2, ct3, ct4)
m := privateKey.Decrypt(cypher5) m := sk.Decrypt(ct5)
if m.Cmp(big.NewInt(26)) != 0 { if m.Cmp(big.NewInt(26)) != 0 {
t.Errorf("Unexpected decrypted value [%v]", m) t.Errorf("Unexpected decrypted value [%v]", m)
} }
} }
func TestAddCypherWithSmallKeyModulus(t *testing.T) { func TestAddCiphertextWithSmallKeyModulus(t *testing.T) {
privateKey := CreatePrivateKey(big.NewInt(7), big.NewInt(5)) sk := CreateSecretKey(big.NewInt(7), big.NewInt(5))
cypher1, _ := privateKey.Encrypt(big.NewInt(30), rand.Reader) ct1, _ := sk.Encrypt(big.NewInt(30), rand.Reader)
cypher2, _ := privateKey.Encrypt(big.NewInt(25), rand.Reader) ct2, _ := sk.Encrypt(big.NewInt(25), rand.Reader)
cypher3, _ := privateKey.Encrypt(big.NewInt(11), rand.Reader) ct3, _ := sk.Encrypt(big.NewInt(11), rand.Reader)
cypher4 := privateKey.Add(cypher1, cypher2, cypher3) ct4 := sk.Add(ct1, ct2, ct3)
m := privateKey.Decrypt(cypher4) m := sk.Decrypt(ct4)
if m.Cmp(big.NewInt(31)) != 0 { if m.Cmp(big.NewInt(31)) != 0 {
t.Errorf("Unexpected decrypted value [%v]", m) t.Errorf("Unexpected decrypted value [%v]", m)
} }
} }
func TestMulCypher(t *testing.T) { func TestMulCiphertext(t *testing.T) {
privateKey := CreatePrivateKey(big.NewInt(17), big.NewInt(13)) p, q := GenKeyPrimes(10)
sk := CreateSecretKey(p, q)
cypher, err := privateKey.Encrypt(big.NewInt(3), rand.Reader) ct, err := sk.Encrypt(big.NewInt(3), rand.Reader)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
cypherMultiple := privateKey.Mul(cypher, big.NewInt(7)) ctMultiple := sk.Mul(ct, big.NewInt(7))
multiple := privateKey.Decrypt(cypherMultiple) multiple := sk.Decrypt(ctMultiple)
// 3 * 7 = 21 // 3 * 7 = 21
if multiple.Cmp(big.NewInt(21)) != 0 { if multiple.Cmp(big.NewInt(21)) != 0 {
@@ -170,19 +172,37 @@ func TestMulCypher(t *testing.T) {
} }
} }
func TestMulCypherWithSmallKeyModulus(t *testing.T) { func TestMulCiphertextWithSmallKeyModulus(t *testing.T) {
privateKey := CreatePrivateKey(big.NewInt(7), big.NewInt(5)) sk := CreateSecretKey(big.NewInt(7), big.NewInt(5))
cypher, err := privateKey.Encrypt(big.NewInt(30), rand.Reader) ct, err := sk.Encrypt(big.NewInt(30), rand.Reader)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
cypherMultiple := privateKey.Mul(cypher, big.NewInt(93)) ctMultiple := sk.Mul(ct, big.NewInt(93))
multiple := privateKey.Decrypt(cypherMultiple) multiple := sk.Decrypt(ctMultiple)
// (30*93) mod (7*5) = 25 // (30*93) mod (7*5) = 25
if multiple.Cmp(big.NewInt(25)) != 0 { if multiple.Cmp(big.NewInt(25)) != 0 {
t.Errorf("Unexpected decrypted value [%v]", multiple) t.Errorf("Unexpected decrypted value [%v]", multiple)
} }
} }
func GenKeyPrimes(bits int) (p, q *big.Int) {
var err error
for {
p, err = rand.Prime(rand.Reader, bits)
if err != nil {
continue
}
q, err = rand.Prime(rand.Reader, bits)
if err != nil || p.Cmp(q) == 0 {
continue
}
break
}
return p, q
}
thresholdkey.go
+15 -15
View File
@@ -171,18 +171,18 @@ func (tk *ThresholdPublicKey) VerifyDecryption(encryptedMessage, decryptedMessag
return nil return nil
} }
// Private key for a threshold Paillier scheme. Holds private information // Secret key for a threshold Paillier scheme. Holds skate information
// for the given decryption server. // for the given decryption server.
// `Id` is the unique identifier of a decryption server and `Share` is a secret // `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. // share generated from hiding polynomial and is used for a partial share decryption.
type ThresholdPrivateKey struct { type ThresholdSecretKey struct {
ThresholdPublicKey ThresholdPublicKey
Id int Id int
Share *big.Int Share *big.Int
} }
// Decrypts the cypher text and returns the partial decryption // Decrypts the ct 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 := new(PartialDecryption)
ret.Id = tpk.Id ret.Id = tpk.Id
exp := new(big.Int).Mul(tpk.Share, new(big.Int).Mul(TWO, tpk.delta())) 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 return ret
} }
func (tpk *ThresholdPrivateKey) copyVi() []*big.Int { func (tpk *ThresholdSecretKey) copyVi() []*big.Int {
ret := make([]*big.Int, len(tpk.Vi)) ret := make([]*big.Int, len(tpk.Vi))
for i, vi := range tpk.Vi { for i, vi := range tpk.Vi {
ret[i] = new(big.Int).Add(vi, big.NewInt(0)) ret[i] = new(big.Int).Add(vi, big.NewInt(0))
@@ -199,7 +199,7 @@ func (tpk *ThresholdPrivateKey) copyVi() []*big.Int {
return ret return ret
} }
func (tpk *ThresholdPrivateKey) getThresholdKey() *ThresholdPublicKey { func (tpk *ThresholdSecretKey) getThresholdKey() *ThresholdPublicKey {
ret := new(ThresholdPublicKey) ret := new(ThresholdPublicKey)
ret.Threshold = tpk.Threshold ret.Threshold = tpk.Threshold
ret.TotalNumberOfDecryptionServers = tpk.TotalNumberOfDecryptionServers ret.TotalNumberOfDecryptionServers = tpk.TotalNumberOfDecryptionServers
@@ -209,13 +209,13 @@ func (tpk *ThresholdPrivateKey) getThresholdKey() *ThresholdPublicKey {
return ret 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(e, tpk.delta())
tmp = new(big.Int).Mul(tmp, tpk.Share) tmp = new(big.Int).Mul(tmp, tpk.Share)
return new(big.Int).Add(r, tmp) 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 := sha256.New()
hash.Write(a.Bytes()) hash.Write(a.Bytes())
hash.Write(b.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{})) return new(big.Int).SetBytes(hash.Sum([]byte{}))
} }
func (tpk *ThresholdPrivateKey) DecryptAndProduceZNP(c *big.Int, random io.Reader) (*PartialDecryptionZKP, error) { func (tpk *ThresholdSecretKey) DecryptAndProduceZKP(c *big.Int, random io.Reader) (*PartialDecryptionZKP, error) {
pd := new(PartialDecryptionZKP) pd := new(PartialDecryptionZKP)
pd.Key = tpk.getThresholdKey() pd.Key = tpk.getThresholdKey()
pd.C = c 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, // Verifies if the partial decryption key is well formed. If well formed,
// the method return nil else an explicative error is returned. // 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) m, err := rand.Int(random, tpk.N)
if err != nil { if err != nil {
return err return err
@@ -264,7 +264,7 @@ func (tpk *ThresholdPrivateKey) Validate(random io.Reader) error {
if err != nil { if err != nil {
return err return err
} }
proof, err := tpk.DecryptAndProduceZNP(c.C, random) proof, err := tpk.DecryptAndProduceZKP(c.C, random)
if err != nil { if err != nil {
return err return err
} }
@@ -281,7 +281,7 @@ type PartialDecryption struct {
// A non-interactive ZKP based on the Fiat–Shamir heuristic. This algorithm // A non-interactive ZKP based on the Fiat–Shamir heuristic. This algorithm
// proves that the decryption server indeed raised secret to his secret exponent // 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). // (`ThresholdKey.Vi`). Recall that v_i = v^(delta s_i).
// //
// The Fiat-Shamir is a non-interactive proof of knowledge heuristic. // The Fiat-Shamir is a non-interactive proof of knowledge heuristic.
@@ -297,7 +297,7 @@ type PartialDecryption struct {
// //
// In our case: // In our case:
// //
// Decryption server i wants to prove that he indeed raised the cyphertext to // Decryption server i wants to prove that he indeed raised the ciphertext to
// his secret exponent s_i during partial decryption. // his secret exponent s_i during partial decryption.
// This is essentialy a protocol for the equality of discrete logs, // This is essentialy a protocol for the equality of discrete logs,
// log_{c^4}(c_i^2) = log_v(v_i). // log_{c^4}(c_i^2) = log_v(v_i).
@@ -309,7 +309,7 @@ type PartialDecryption struct {
// E = HASH(a, b, c^4, c_i^2), where // E = HASH(a, b, c^4, c_i^2), where
// a = (c^4)^r mod n^2 // a = (c^4)^r mod n^2
// b = V^r mod n^2 // b = V^r mod n^2
// c is a cyphertext, // c is a ciphertext,
// V is a generator from ThresholdKey.V // V is a generator from ThresholdKey.V
// c_i is a partial decryption for this server // c_i is a partial decryption for this server
// - Compute Z as: // - Compute Z as:
@@ -334,7 +334,7 @@ type PartialDecryptionZKP struct {
Key *ThresholdPublicKey // the public key used to encrypt Key *ThresholdPublicKey // the public key used to encrypt
E *big.Int // the challenge E *big.Int // the challenge
Z *big.Int // the value needed to check to verify the decryption Z *big.Int // the value needed to check to verify the decryption
C *big.Int // the input cypher text C *big.Int // the input ct text
} }
func (pd *PartialDecryptionZKP) verifyPart1() *big.Int { func (pd *PartialDecryptionZKP) verifyPart1() *big.Int {
thresholdkey_generator.go
+8 -7
View File
@@ -240,9 +240,10 @@ func (tkg *ThresholdKeyGenerator) createViArray(shares []*big.Int) (viArray []*b
return viArray return viArray
} }
func (tkg *ThresholdKeyGenerator) createPrivateKey(i int, share *big.Int, viArray []*big.Int) *ThresholdPrivateKey { func (tkg *ThresholdKeyGenerator) createSecretKey(i int, share *big.Int, viArray []*big.Int) *ThresholdSecretKey {
ret := new(ThresholdPrivateKey) ret := new(ThresholdSecretKey)
ret.N = tkg.n ret.N = tkg.n
ret.G = new(big.Int).Add(tkg.n, big.NewInt(1))
ret.V = tkg.v ret.V = tkg.v
ret.TotalNumberOfDecryptionServers = tkg.TotalNumberOfDecryptionServers ret.TotalNumberOfDecryptionServers = tkg.TotalNumberOfDecryptionServers
@@ -253,22 +254,22 @@ func (tkg *ThresholdKeyGenerator) createPrivateKey(i int, share *big.Int, viArra
return ret return ret
} }
func (tkg *ThresholdKeyGenerator) createPrivateKeys() []*ThresholdPrivateKey { func (tkg *ThresholdKeyGenerator) createSecretKeys() []*ThresholdSecretKey {
shares := tkg.createShares() shares := tkg.createShares()
viArray := tkg.createViArray(shares) viArray := tkg.createViArray(shares)
ret := make([]*ThresholdPrivateKey, tkg.TotalNumberOfDecryptionServers) ret := make([]*ThresholdSecretKey, tkg.TotalNumberOfDecryptionServers)
for i := 0; i < tkg.TotalNumberOfDecryptionServers; i++ { 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 return ret
} }
func (tkg *ThresholdKeyGenerator) Generate() ([]*ThresholdPrivateKey, error) { func (tkg *ThresholdKeyGenerator) Generate() ([]*ThresholdSecretKey, error) {
if err := tkg.initNumerialValues(); err != nil { if err := tkg.initNumerialValues(); err != nil {
return nil, err return nil, err
} }
if err := tkg.generateHidingPolynomial(); err != nil { if err := tkg.generateHidingPolynomial(); err != nil {
return nil, err return nil, err
} }
return tkg.createPrivateKeys(), nil return tkg.createSecretKeys(), nil
} }
thresholdkey_test.go
+26 -26
View File
@@ -7,7 +7,7 @@ import (
"testing" "testing"
) )
func getThresholdPrivateKey() *ThresholdPrivateKey { func getThresholdSecretKey() *ThresholdSecretKey {
tkh, err := GetThresholdKeyGenerator(32, 10, 6, rand.Reader) tkh, err := GetThresholdKeyGenerator(32, 10, 6, rand.Reader)
if err != nil { if err != nil {
panic(err) panic(err)
@@ -55,7 +55,7 @@ func TestCombineSharesConstant(t *testing.T) {
} }
func TestDecrypt(t *testing.T) { func TestDecrypt(t *testing.T) {
key := new(ThresholdPrivateKey) key := new(ThresholdSecretKey)
key.TotalNumberOfDecryptionServers = 10 key.TotalNumberOfDecryptionServers = 10
key.N = b(101 * 103) key.N = b(101 * 103)
key.Share = b(862) key.Share = b(862)
@@ -73,7 +73,7 @@ func TestDecrypt(t *testing.T) {
} }
func TestCopyVi(t *testing.T) { func TestCopyVi(t *testing.T) {
key := new(ThresholdPrivateKey) key := new(ThresholdSecretKey)
key.Vi = []*big.Int{b(34), b(2), b(29)} key.Vi = []*big.Int{b(34), b(2), b(29)}
vi := key.copyVi() vi := key.copyVi()
if !reflect.DeepEqual(vi, key.Vi) { if !reflect.DeepEqual(vi, key.Vi) {
@@ -86,7 +86,7 @@ func TestCopyVi(t *testing.T) {
} }
func TestEncryptWithThresholdKey(t *testing.T) { func TestEncryptWithThresholdKey(t *testing.T) {
pd := getThresholdPrivateKey() pd := getThresholdSecretKey()
_, err := pd.Encrypt(big.NewInt(876), rand.Reader) _, err := pd.Encrypt(big.NewInt(876), rand.Reader)
if err != nil { if err != nil {
t.Fail() t.Fail()
@@ -94,7 +94,7 @@ func TestEncryptWithThresholdKey(t *testing.T) {
} }
func TestDecryptWithThresholdKey(t *testing.T) { func TestDecryptWithThresholdKey(t *testing.T) {
pd := getThresholdPrivateKey() pd := getThresholdSecretKey()
c, err := pd.Encrypt(big.NewInt(876), rand.Reader) c, err := pd.Encrypt(big.NewInt(876), rand.Reader)
if err != nil { if err != nil {
t.Fail() t.Fail()
@@ -130,18 +130,18 @@ func TestVerifyPart2(t *testing.T) {
} }
} }
func TestDecryptAndProduceZNP(t *testing.T) { func TestDecryptAndProduceZKP(t *testing.T) {
pd := getThresholdPrivateKey() pd := getThresholdSecretKey()
c, err := pd.Encrypt(big.NewInt(876), rand.Reader) c, err := pd.Encrypt(big.NewInt(876), rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
znp, err := pd.DecryptAndProduceZNP(c.C, rand.Reader) ZKP, err := pd.DecryptAndProduceZKP(c.C, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
if !znp.Verify() { if !ZKP.Verify() {
t.Fail() t.Fail()
} }
} }
@@ -234,7 +234,7 @@ func TestEncryptingDecrypting(t *testing.T) {
t.Error(err) t.Error(err)
} }
if n(message) != n(message2) { if n(message) != n(message2) {
t.Error("The decrypted cyphered is not original massage but ", message2) t.Error("The decrypted ciphered is not original massage but ", message2)
} }
} }
@@ -249,13 +249,13 @@ func TestHomomorphicThresholdEncryption(t *testing.T) {
plainText1 := b(13) plainText1 := b(13)
plainText2 := b(19) plainText2 := b(19)
cypher1, _ := tpks[0].Encrypt(plainText1, rand.Reader) cipher1, _ := tpks[0].Encrypt(plainText1, rand.Reader)
cypher2, _ := tpks[1].Encrypt(plainText2, rand.Reader) cipher2, _ := tpks[1].Encrypt(plainText2, rand.Reader)
cypher3 := tpks[0].Add(cypher1, cypher2) cipher3 := tpks[0].Add(cipher1, cipher2)
share1 := tpks[0].Decrypt(cypher3.C) share1 := tpks[0].Decrypt(cipher3.C)
share2 := tpks[1].Decrypt(cypher3.C) share2 := tpks[1].Decrypt(cipher3.C)
combined, _ := tpks[0].CombinePartialDecryptions([]*PartialDecryption{share1, share2}) combined, _ := tpks[0].CombinePartialDecryptions([]*PartialDecryption{share1, share2})
@@ -283,7 +283,7 @@ func TestDecryption(t *testing.T) {
} }
func TestValidate(t *testing.T) { func TestValidate(t *testing.T) {
pk := getThresholdPrivateKey() pk := getThresholdSecretKey()
if err := pk.Validate(rand.Reader); err != nil { if err := pk.Validate(rand.Reader); err != nil {
t.Error(err) t.Error(err)
} }
@@ -308,11 +308,11 @@ func TestCombinePartialDecryptionsZKP(t *testing.T) {
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
share1, err := tpks[0].DecryptAndProduceZNP(c.C, rand.Reader) share1, err := tpks[0].DecryptAndProduceZKP(c.C, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
share2, err := tpks[1].DecryptAndProduceZNP(c.C, rand.Reader) share2, err := tpks[1].DecryptAndProduceZKP(c.C, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@@ -321,7 +321,7 @@ func TestCombinePartialDecryptionsZKP(t *testing.T) {
t.Error(err) t.Error(err)
} }
if n(message) != n(message2) { if n(message) != n(message2) {
t.Error("The decrypted cyphered is not original massage but ", message2) t.Error("The decrypted ciphered is not original massage but ", message2)
} }
share1.E = b(687687678) share1.E = b(687687678)
_, err = tpks[0].CombinePartialDecryptionsZKP([]*PartialDecryptionZKP{share1, share2}) _, err = tpks[0].CombinePartialDecryptionsZKP([]*PartialDecryptionZKP{share1, share2})
@@ -357,7 +357,7 @@ func TestCombinePartialDecryptionsWith100Shares(t *testing.T) {
t.Error(err) t.Error(err)
} }
if n(message) != n(message2) { if n(message) != n(message2) {
t.Error("The decrypted cyphered is not original massage but ", message2) t.Error("The decrypted ciphered is not original massage but ", message2)
} }
} }
@@ -374,15 +374,15 @@ func TestVerifyDecryption(t *testing.T) {
t.Error(err) t.Error(err)
} }
expt := b(101) expt := b(101)
cypher, err := tpks[0].Encrypt(expt, rand.Reader) ct, err := tpks[0].Encrypt(expt, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
pd1, err := tpks[0].DecryptAndProduceZNP(cypher.C, rand.Reader) pd1, err := tpks[0].DecryptAndProduceZKP(ct.C, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
pd2, err := tpks[1].DecryptAndProduceZNP(cypher.C, rand.Reader) pd2, err := tpks[1].DecryptAndProduceZKP(ct.C, rand.Reader)
if err != nil { if err != nil {
t.Error(err) t.Error(err)
} }
@@ -391,13 +391,13 @@ func TestVerifyDecryption(t *testing.T) {
t.Error(err) t.Error(err)
} }
if err = pk.VerifyDecryption(cypher.C, b(101), pds); err != nil { if err = pk.VerifyDecryption(ct.C, b(101), pds); err != nil {
t.Error(err) t.Error(err)
} }
if err = pk.VerifyDecryption(cypher.C, b(100), pds); err == nil { if err = pk.VerifyDecryption(ct.C, b(100), pds); err == nil {
t.Error(err) t.Error(err)
} }
if err = pk.VerifyDecryption(new(big.Int).Add(b(1), cypher.C), b(101), pds); err == nil { if err = pk.VerifyDecryption(new(big.Int).Add(b(1), ct.C), b(101), pds); err == nil {
t.Error(err) t.Error(err)
} }
} }