Merge pull request #18 from lca1/dev

Small fix for medco-unlynx

deployment/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.11 as build
+FROM golang:1.12 as build
 
 COPY ./ /src
 

lib/aggregation/aggregation_proofs_test.go

@@ -7,12 +7,10 @@ import (
  "github.com/stretchr/testify/assert"
 
  "github.com/lca1/unlynx/lib"
- "go.dedis.ch/kyber/v3/util/key"
 )
 
 func TestAggregationProof(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- pubKey, _ := keys.Public, keys.Private
+ _, pubKey := libunlynx.GenKey()
 
  tab1 := []int64{1, 2, 3, 6}
  testCV1 := *libunlynx.EncryptIntVector(pubKey, tab1)

lib/crypto.go

@@ -93,16 +93,20 @@ func NewDeterministicCipherVector(length int) *DeterministCipherVector {
 // Key Pairs
 //----------------------------------------------------------------------------------------------------------------------
 
+// GenKey generate an ElGamal public/private key pair.
+func GenKey() (kyber.Scalar, kyber.Point) {
+ keys := key.NewKeyPair(SuiTe)
+ return keys.Private, keys.Public
+}
+
 // GenKeys generates ElGamal public/private key pairs.
 func GenKeys(n int) (kyber.Point, []kyber.Scalar, []kyber.Point) {
  priv := make([]kyber.Scalar, n)
  pub := make([]kyber.Point, n)
 
  group := SuiTe.Point().Null()
  for i := 0; i < n; i++ {
- keys := key.NewKeyPair(SuiTe)
- pub[i] = keys.Public
- priv[i] = keys.Private
+ priv[i], pub[i] = GenKey()
  group.Add(group, pub[i])
  }
  return group, priv, pub

lib/crypto_test.go

@@ -4,7 +4,6 @@ import (
  "github.com/lca1/unlynx/lib"
  "github.com/stretchr/testify/assert"
  "go.dedis.ch/kyber/v3"
- "go.dedis.ch/kyber/v3/util/key"
  "go.dedis.ch/kyber/v3/util/random"
  "go.dedis.ch/onet/v3/log"
  "reflect"
@@ -15,8 +14,7 @@ import (
 
 // TestNullCipherText verifies encryption, decryption and behavior of null ciphertexts.
 func TestNullCipherText(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  nullEnc := libunlynx.EncryptInt(pubKey, 0)
  nullDec := libunlynx.DecryptInt(secKey, *nullEnc)
@@ -37,8 +35,7 @@ func TestNullCipherText(t *testing.T) {
 
 // TestEncryption tests a relatively high number of encryptions.
 func TestEncryption(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- _, pubKey := keys.Private, keys.Public
+ _, pubKey := libunlynx.GenKey()
 
  nbrEncryptions := 10
  for i := 0; i < nbrEncryptions; i++ {
@@ -47,8 +44,7 @@ func TestEncryption(t *testing.T) {
 }
 
 func TestEncryptIntVector(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- _, pubKey := keys.Private, keys.Public
+ _, pubKey := libunlynx.GenKey()
 
  nbrEncryptions := 200
  arr := make([]int64, nbrEncryptions)
@@ -61,9 +57,7 @@ func TestEncryptIntVector(t *testing.T) {
 // TestDecryptionConcurrent test the multiple encryptions/decryptions at the same time
 func TestDecryptionConcurrent(t *testing.T) {
  numThreads := 5
-
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  wg := libunlynx.StartParallelize(numThreads)
 
@@ -82,9 +76,7 @@ func TestDecryptionConcurrent(t *testing.T) {
 // TestDecryptionConcurrent test the multiple encryptions/decryptions at the same time
 func TestDecryptionNegConcurrent(t *testing.T) {
  numThreads := 5
-
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  wg := libunlynx.StartParallelize(numThreads)
 
@@ -110,8 +102,7 @@ func TestDecryptionNegConcurrent(t *testing.T) {
 
 // TestNullCipherText verifies encryption, decryption and behavior of null cipherVectors.
 func TestNullCipherVector(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  nullVectEnc := *libunlynx.NullCipherVector(10, pubKey)
  nullVectDec := libunlynx.DecryptIntVector(secKey, &nullVectEnc)
@@ -132,8 +123,7 @@ func TestNullCipherVector(t *testing.T) {
 
 // TestHomomorphicOpp tests homomorphic addition.
 func TestHomomorphicOpp(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  cv1 := libunlynx.EncryptIntVector(pubKey, []int64{0, 1, 2, 3, 100})
  cv2 := libunlynx.EncryptIntVector(pubKey, []int64{0, 0, 1, 3, 3})
@@ -207,8 +197,7 @@ func TestAbstractPointsConverter(t *testing.T) {
 
 // TestCiphertextConverter tests the Ciphertext converter (to bytes)
 func TestCiphertextConverter(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := int64(2)
  ct := libunlynx.EncryptInt(pubKey, target)
@@ -227,8 +216,7 @@ func TestCiphertextConverter(t *testing.T) {
 
 // TestCipherVectorConverter tests the CipherVector converter (to bytes)
 func TestCipherVectorConverter(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := []int64{0, 1, 3, 103, 103}
  cv := libunlynx.EncryptIntVector(pubKey, target)
@@ -261,8 +249,7 @@ func TestIntArrayToCipherVector(t *testing.T) {
 }
 
 func TestB64Serialization(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := []int64{0, 1, 3, 103, 103}
  cv := libunlynx.EncryptIntVector(pubKey, target)
@@ -291,8 +278,7 @@ func TestB64Serialization(t *testing.T) {
 }
 
 func TestEncryptScalar(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := int64(5)
  scal := libunlynx.SuiTe.Scalar().SetInt64(target)
@@ -302,8 +288,7 @@ func TestEncryptScalar(t *testing.T) {
 }
 
 func TestEncryptScalarVector(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := []int64{0, 1, 3, 103, 103}
  targetScal := make([]kyber.Scalar, len(target))
@@ -319,8 +304,7 @@ func TestEncryptScalarVector(t *testing.T) {
 }
 
 func TestDecryptIntVectorWithNeg(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := []int64{0, -1, -3, -103, -103}
  cv := libunlynx.EncryptIntVector(pubKey, target)
@@ -332,8 +316,7 @@ func TestDecryptIntVectorWithNeg(t *testing.T) {
 }
 
 func TestDecryptCheckZero(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  ctZero := *libunlynx.EncryptInt(pubKey, int64(0))
  assert.Equal(t, libunlynx.DecryptCheckZero(secKey, ctZero), int64(0))
@@ -343,8 +326,7 @@ func TestDecryptCheckZero(t *testing.T) {
 }
 
 func TestDecryptCheckZeroVector(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := []int64{0, 1, 5, 0, 3}
 
@@ -359,8 +341,7 @@ func TestDecryptCheckZeroVector(t *testing.T) {
 }
 
 func TestNewDeterministicCipherText(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, _ := keys.Private, keys.Public
+ secKey, _ := libunlynx.GenKey()
 
  dt1 := libunlynx.NewDeterministicCipherText()
  dt2 := libunlynx.NewDeterministicCipherText()
@@ -373,8 +354,7 @@ func TestNewDeterministicCipherText(t *testing.T) {
 }
 
 func TestNewDeterministicCipherVector(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, _ := keys.Private, keys.Public
+ secKey, _ := libunlynx.GenKey()
 
  k := 5
  dtv1 := *libunlynx.NewDeterministicCipherVector(k)
@@ -395,8 +375,7 @@ func TestNewDeterministicCipherVector(t *testing.T) {
 }
 
 func TestDeterministicCipherTextKey(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- _, pubKey := keys.Private, keys.Public
+ _, pubKey := libunlynx.GenKey()
 
  k := 5
  target := []int64{0, 1, 3, 103, 103}
@@ -411,8 +390,7 @@ func TestDeterministicCipherTextKey(t *testing.T) {
 }
 
 func TestSerializePoint(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  target := int64(1)
  ct := *libunlynx.EncryptInt(pubKey, target)

lib/deterministic_tag/deterministic_tag_proofs_test.go

@@ -7,15 +7,12 @@ import (
  "github.com/lca1/unlynx/lib/deterministic_tag"
  "github.com/stretchr/testify/assert"
  "go.dedis.ch/kyber/v3"
- "go.dedis.ch/kyber/v3/util/key"
 )
 
 func TestDeterministicTagProofCreation(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- pubKey, secKey := keys.Public, keys.Private
- pubKeyNew := key.NewKeyPair(libunlynx.SuiTe).Public
-
- secretContrib := key.NewKeyPair(libunlynx.SuiTe).Private
+ secKey, pubKey := libunlynx.GenKey()
+ _, pubKeyNew := libunlynx.GenKey()
+ secretContrib, _ := libunlynx.GenKey()
 
  cipherOne := *libunlynx.EncryptInt(pubKey, 10)
 
@@ -72,10 +69,8 @@ func TestDeterministicTagProofCreation(t *testing.T) {
 }
 
 func TestDeterministicTaggingAdditionProof(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- pubKey, secKey := keys.Public, keys.Private
-
- secretContrib := key.NewKeyPair(libunlynx.SuiTe).Private
+ secKey, pubKey := libunlynx.GenKey()
+ secretContrib, _ := libunlynx.GenKey()
 
  cipherOne := *libunlynx.EncryptInt(pubKey, 10)
  toAdd := libunlynx.SuiTe.Point().Mul(secKey, libunlynx.SuiTe.Point().Base())

lib/key_switch/key_switch_proofs_test.go

@@ -15,7 +15,6 @@ import (
 // TesKeySwitchingProof test the creation and verification of key switching proofs
 func TestKeySwitchingProof(t *testing.T) {
  keysTarget := key.NewKeyPair(libunlynx.SuiTe)
-
  keys := key.NewKeyPair(libunlynx.SuiTe)
 
  ct1 := libunlynx.EncryptInt(keys.Public, int64(1))

lib/key_switch/key_switch_test.go

@@ -14,8 +14,8 @@ import (
 // TesKeySwitchingProof test key switching of a sequence of ciphertexts
 func TestKeySwitchSequence(t *testing.T) {
  keysTarget := key.NewKeyPair(libunlynx.SuiTe)
-
  keys := key.NewKeyPair(libunlynx.SuiTe)
+
  ct1 := libunlynx.EncryptInt(keys.Public, int64(1))
  ct2 := libunlynx.EncryptInt(keys.Public, int64(2))
 

lib/structs_test.go

@@ -8,7 +8,6 @@ import (
  "github.com/lca1/unlynx/lib/tools"
  "github.com/stretchr/testify/assert"
  "go.dedis.ch/kyber/v3"
- "go.dedis.ch/kyber/v3/util/key"
 )
 
 // TestAddClientResponse tests the addition of two client response objects
@@ -18,8 +17,7 @@ func TestAddClientResponse(t *testing.T) {
 
  sum := []int64{0, 2, 4, 6, 8}
 
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  cr1 := libunlynx.FilteredResponse{GroupByEnc: *libunlynx.EncryptIntVector(pubKey, grouping), AggregatingAttributes: *libunlynx.EncryptIntVector(pubKey, aggregating)}
  cr2 := libunlynx.FilteredResponse{GroupByEnc: *libunlynx.EncryptIntVector(pubKey, grouping), AggregatingAttributes: *libunlynx.EncryptIntVector(pubKey, aggregating)}
@@ -34,8 +32,7 @@ func TestAddClientResponse(t *testing.T) {
 }
 
 func TestAddInMap(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- _, pubKey := keys.Private, keys.Public
+ _, pubKey := libunlynx.GenKey()
  gkey := libunlynx.GroupingKey("test")
 
  cv := make(libunlynx.CipherVector, 5)
@@ -71,8 +68,7 @@ func decryptMapBytes(secKey kyber.Scalar, data map[string][]byte) (map[string]in
 
 // TestEncryptDpClearResponse tests the encryption of a DpClearResponse object
 func TestEncryptDpClearResponse(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  groupingClear := libunlynxtools.ConvertDataToMap([]int64{2}, "g", 0)
  groupingEnc := libunlynxtools.ConvertDataToMap([]int64{1}, "g", len(groupingClear))
@@ -112,8 +108,7 @@ func TestFilteredResponseConverter(t *testing.T) {
  grouping := []int64{1}
  aggregating := []int64{0, 1, 3, 103, 103}
 
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  cr := libunlynx.FilteredResponse{GroupByEnc: *libunlynx.EncryptIntVector(pubKey, grouping), AggregatingAttributes: *libunlynx.EncryptIntVector(pubKey, aggregating)}
 
@@ -129,8 +124,7 @@ func TestFilteredResponseConverter(t *testing.T) {
 
 // TestFilteredResponseDetConverter tests the FilteredResponseDet converter (to bytes). In the meantime we also test the Key and UnKey function ... That is the way to go :D
 func TestClientResponseDetConverter(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  grouping := []int64{1}
  aggregating := []int64{0, 1, 3, 103, 103}
@@ -156,8 +150,7 @@ func TestProcessResponseConverter(t *testing.T) {
  grouping := []int64{1}
  aggregating := []int64{0, 1, 3, 103, 103}
 
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  pr := libunlynx.ProcessResponse{
  WhereEnc: *libunlynx.EncryptIntVector(pubKey, whereEnc),
@@ -180,8 +173,7 @@ func TestProcessResponseDetConverter(t *testing.T) {
  grouping := []int64{1}
  aggregating := []int64{0, 1, 3, 103, 103}
 
- keys := key.NewKeyPair(libunlynx.SuiTe)
- _, pubKey := keys.Private, keys.Public
+ _, pubKey := libunlynx.GenKey()
 
  pr := libunlynx.ProcessResponse{
  WhereEnc: *libunlynx.EncryptIntVector(pubKey, whereEnc),
@@ -212,8 +204,7 @@ func TestProcessResponseDetConverter(t *testing.T) {
 }
 
 func TestDPResponseConverter(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  k := 5
  dpResponseToSend := libunlynx.DpResponseToSend{
@@ -261,8 +252,7 @@ func TestDPResponseConverter(t *testing.T) {
 }
 
 func TestMapBytesToMapCipherText(t *testing.T) {
- keys := key.NewKeyPair(libunlynx.SuiTe)
- secKey, pubKey := keys.Private, keys.Public
+ secKey, pubKey := libunlynx.GenKey()
 
  k := 5
  bMap := make(map[string][]byte)