New structs for pseudonym system keys (xlab-si#75)

This commit adds definitions of PubKey, PubKeyEC and SecKey, which
correspond to public keys for both implementations of pseudonym
system scheme, and their secret keys, which are of the same type
for both implementations. It replaces old OrgPubKeysEC and OrgPubKeys
structs with newly introduced ones. Moreover, functions and structs that did
not accept key parameters as structs were updated. Changes are propagated
to all the affected packages.

Signed-off-by: Manca Bizjak <[email protected]>

Author: mancabizjak

client/compatibility/doc.go

@@ -65,8 +65,8 @@
 //	Credential
 //	CredentialEC
 //	ECGroupElement
-//	OrgPubKeys
-//	OrgPubKeysEC
+//	PubKey
+//	PubKeyEC
 //	Transcript
 //	TranscriptEC
 // 	Pseudonym

client/compatibility/pseudonymsys.go

@@ -72,30 +72,29 @@ func (c *Credential) getNativeType() (*pseudonymsys.Credential, error) {
 	return cred, nil
 }
 
-// OrgPubKeys represents an equivalent of pseudonymsys.OrgPubKeys, but has string
+// PubKey represents an equivalent of pseudonymsys.PubKey, but has string
 // field types to overcome type restrictions of Go language binding tools.
-type OrgPubKeys struct {
+type PubKey struct {
 	H1 string
 	H2 string
 }
 
-func NewOrgPubKeys(h1, h2 string) *OrgPubKeys {
-	return &OrgPubKeys{
+func NewPubKey(h1, h2 string) *PubKey {
+	return &PubKey{
 		H1: h1,
 		H2: h2,
 	}
 }
 
-// getNativeType translates compatibility OrgPubKeys to emmy's native pseudonymsys.OrgPubKeys.
-func (k *OrgPubKeys) getNativeType() (*pseudonymsys.OrgPubKeys, error) {
+// getNativeType translates compatibility PubKey to emmy's native pseudonymsys.PubKey.
+func (k *PubKey) getNativeType() (*pseudonymsys.PubKey, error) {
 	h1, h1Ok := new(big.Int).SetString(k.H1, 10)
 	h2, h2Ok := new(big.Int).SetString(k.H2, 10)
 	if !h1Ok || !h2Ok {
-		return nil, fmt.Errorf("pubKeys.h1 or pubKeys.h2: %s", ArgsConversionError)
+		return nil, fmt.Errorf("pubKey.h1 or pubKey.h2: %s", ArgsConversionError)
 	}
 
-	orgPubKeys := pseudonymsys.NewOrgPubKeys(h1, h2)
-	return orgPubKeys, nil
+	return pseudonymsys.NewPubKey(h1, h2), nil
 }
 
 // Transcript represents an equivalent of dlogproofs.Transcript, but has string
@@ -187,7 +186,7 @@ func (c *PseudonymsysClient) GenerateNym(userSecret string,
 }
 
 func (c *PseudonymsysClient) ObtainCredential(userSecret string,
-	nym *Pseudonym, pubKeys *OrgPubKeys) (*Credential, error) {
+	nym *Pseudonym, publicKey *PubKey) (*Credential, error) {
 	// Translate secret
 	secret, secretOk := new(big.Int).SetString(userSecret, 10)
 	if !secretOk {
@@ -200,14 +199,14 @@ func (c *PseudonymsysClient) ObtainCredential(userSecret string,
 		return nil, err
 	}
 
-	// Translate OrgPubKeys
-	orgPubKeys, err := pubKeys.getNativeType()
+	// Translate PubKey
+	pubKey, err := publicKey.getNativeType()
 	if err != nil {
 		return nil, err
 	}
 
 	// Call PseudonymsysClient client with translated parameters
-	credential, err := c.PseudonymsysClient.ObtainCredential(secret, pseudonym, orgPubKeys)
+	credential, err := c.PseudonymsysClient.ObtainCredential(secret, pseudonym, pubKey)
 	if err != nil {
 		return nil, err
 	}

client/compatibility/pseudonymsys_ec.go

@@ -28,33 +28,32 @@ import (
 	"github.com/xlab-si/emmy/crypto/zkp/schemes/pseudonymsys"
 )
 
-// OrgPubKeysEC represents an equivalent of pseudonymsys.OrgPubKeysEC,
+// PubKeyEC represents an equivalent of pseudonymsys.PubKeyEC,
 // but has field types compatible with Go language binding tools.
-type OrgPubKeysEC struct {
+type PubKeyEC struct {
 	H1 *ECGroupElement
 	H2 *ECGroupElement
 }
 
-func NewOrgPubKeysEC(h1, h2 *ECGroupElement) *OrgPubKeysEC {
-	return &OrgPubKeysEC{
+func NewPubKeyEC(h1, h2 *ECGroupElement) *PubKeyEC {
+	return &PubKeyEC{
 		H1: h1,
 		H2: h2,
 	}
 }
 
-// getNativeType translates compatibility OrgPubKeysEC to emmy's native pseudonymsys.OrgPubKeysEC.
-func (k *OrgPubKeysEC) getNativeType() (*pseudonymsys.OrgPubKeysEC, error) {
+// getNativeType translates compatibility PubKeyEC to emmy's native pseudonymsys.PubKeyEC.
+func (k *PubKeyEC) getNativeType() (*pseudonymsys.PubKeyEC, error) {
 	h1, err := k.H1.getNativeType()
 	if err != nil {
-		return nil, fmt.Errorf("pubKeys.H1: %s", err)
+		return nil, fmt.Errorf("pubKey.H1: %s", err)
 	}
 	h2, err := k.H2.getNativeType()
 	if err != nil {
-		return nil, fmt.Errorf("pubKeys.H2: %s", err)
+		return nil, fmt.Errorf("pubKey.H2: %s", err)
 	}
 
-	orgPubKeys := pseudonymsys.NewOrgPubKeysEC(h1, h2)
-	return orgPubKeys, nil
+	return pseudonymsys.NewPubKeyEC(h1, h2), nil
 }
 
 // TranscriptEC represents an equivalent of dlogproofs.TranscriptEC, but has string
@@ -204,7 +203,7 @@ func (c *PseudonymsysClientEC) GenerateNym(userSecret string,
 }
 
 func (c *PseudonymsysClientEC) ObtainCredential(userSecret string,
-	nym *PseudonymEC, pubKeys *OrgPubKeysEC) (*CredentialEC, error) {
+	nym *PseudonymEC, publicKey *PubKeyEC) (*CredentialEC, error) {
 	// Translate secret
 	secret, secretOk := new(big.Int).SetString(userSecret, 10)
 	if !secretOk {
@@ -217,14 +216,14 @@ func (c *PseudonymsysClientEC) ObtainCredential(userSecret string,
 		return nil, err
 	}
 
-	// Translate OrgPubKeysEC
-	orgPubKeys, err := pubKeys.getNativeType()
+	// Translate PubKeyEC
+	pubKey, err := publicKey.getNativeType()
 	if err != nil {
 		return nil, err
 	}
 
 	// Call PseudonymsysClientEC client with translated parameters
-	credential, err := c.PseudonymsysClientEC.ObtainCredential(secret, pseudonym, orgPubKeys)
+	credential, err := c.PseudonymsysClientEC.ObtainCredential(secret, pseudonym, pubKey)
 	if err != nil {
 		return nil, err
 	}

client/pseudonymsys.go

@@ -129,7 +129,7 @@ func (c *PseudonymsysClient) GenerateNym(userSecret *big.Int,
 
 // ObtainCredential returns anonymous credential.
 func (c *PseudonymsysClient) ObtainCredential(userSecret *big.Int,
-	nym *pseudonymsys.Pseudonym, orgPubKeys *pseudonymsys.OrgPubKeys) (
+	nym *pseudonymsys.Pseudonym, orgPubKeys *pseudonymsys.PubKey) (
 	*pseudonymsys.Credential, error) {
 	if err := c.openStream(c.grpcClient, "ObtainCredential"); err != nil {
 		return nil, err

client/pseudonymsys_ec.go

@@ -139,7 +139,7 @@ func (c *PseudonymsysClientEC) GenerateNym(userSecret *big.Int,
 
 // ObtainCredential returns anonymous credential.
 func (c *PseudonymsysClientEC) ObtainCredential(userSecret *big.Int,
-	nym *pseudonymsys.PseudonymEC, orgPubKeys *pseudonymsys.OrgPubKeysEC) (
+	nym *pseudonymsys.PseudonymEC, orgPubKeys *pseudonymsys.PubKeyEC) (
 	*pseudonymsys.CredentialEC, error) {
 	if err := c.openStream(c.grpcClient, "ObtainCredential_EC"); err != nil {
 		return nil, err

client/pseudonymsys_ec_test.go

@@ -24,7 +24,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/xlab-si/emmy/config"
 	"github.com/xlab-si/emmy/crypto/groups"
-	"github.com/xlab-si/emmy/crypto/zkp/schemes/pseudonymsys"
 )
 
 func TestPseudonymsysEC(t *testing.T) {
@@ -63,10 +62,7 @@ func TestPseudonymsysEC(t *testing.T) {
 	assert.NotNil(t, err, "Should produce an error")
 
 	orgName := "org1"
-	h1X, h1Y, h2X, h2Y := config.LoadPseudonymsysOrgPubKeysEC(orgName)
-	h1 := groups.NewECGroupElement(h1X, h1Y)
-	h2 := groups.NewECGroupElement(h2X, h2Y)
-	orgPubKeys := pseudonymsys.NewOrgPubKeysEC(h1, h2)
+	orgPubKeys := config.LoadPseudonymsysOrgPubKeysEC(orgName)
 	credential, err := c1.ObtainCredential(userSecret, nym1, orgPubKeys)
 	if err != nil {
 		t.Errorf(err.Error())

client/pseudonymsys_test.go

@@ -24,7 +24,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/xlab-si/emmy/config"
-	"github.com/xlab-si/emmy/crypto/zkp/schemes/pseudonymsys"
 	"github.com/xlab-si/emmy/server"
 )
 
@@ -38,7 +37,7 @@ func TestPseudonymsys(t *testing.T) {
 	}
 
 	// usually the endpoint is different from the one used for CA:
-  c1, err := NewPseudonymsysClient(testGrpcClientConn, group)
+	c1, err := NewPseudonymsysClient(testGrpcClientConn, group)
 	userSecret := c1.GenerateMasterKey()
 
 	masterNym := caClient.GenerateMasterNym(userSecret)
@@ -66,8 +65,7 @@ func TestPseudonymsys(t *testing.T) {
 	assert.NotNil(t, err, "Should produce an error")
 
 	orgName := "org1"
-	h1, h2 := config.LoadPseudonymsysOrgPubKeys(orgName)
-	orgPubKeys := pseudonymsys.NewOrgPubKeys(h1, h2)
+	orgPubKeys := config.LoadPseudonymsysOrgPubKeys(orgName)
 	credential, err := c1.ObtainCredential(userSecret, nym1, orgPubKeys)
 	if err != nil {
 		t.Errorf(err.Error())

config/config.go

@@ -26,6 +26,7 @@ import (
 
 	"github.com/spf13/viper"
 	"github.com/xlab-si/emmy/crypto/groups"
+	"github.com/xlab-si/emmy/crypto/zkp/schemes/pseudonymsys"
 )
 
 // init loads the default config file
@@ -138,27 +139,30 @@ func LoadQRRSA() *groups.QRRSA {
 	return qr
 }
 
-func LoadPseudonymsysOrgSecrets(orgName, dlogType string) (*big.Int, *big.Int) {
+func LoadPseudonymsysOrgSecrets(orgName, dlogType string) *pseudonymsys.SecKey {
 	org := viper.GetStringMap(fmt.Sprintf("pseudonymsys.%s.%s", orgName, dlogType))
 	s1, _ := new(big.Int).SetString(org["s1"].(string), 10)
 	s2, _ := new(big.Int).SetString(org["s2"].(string), 10)
-	return s1, s2
+	return pseudonymsys.NewSecKey(s1, s2)
 }
 
-func LoadPseudonymsysOrgPubKeys(orgName string) (*big.Int, *big.Int) {
+func LoadPseudonymsysOrgPubKeys(orgName string) *pseudonymsys.PubKey {
 	org := viper.GetStringMap(fmt.Sprintf("pseudonymsys.%s.%s", orgName, "dlog"))
 	h1, _ := new(big.Int).SetString(org["h1"].(string), 10)
 	h2, _ := new(big.Int).SetString(org["h2"].(string), 10)
-	return h1, h2
+	return pseudonymsys.NewPubKey(h1, h2)
 }
 
-func LoadPseudonymsysOrgPubKeysEC(orgName string) (*big.Int, *big.Int, *big.Int, *big.Int) {
+func LoadPseudonymsysOrgPubKeysEC(orgName string) *pseudonymsys.PubKeyEC {
 	org := viper.GetStringMap(fmt.Sprintf("pseudonymsys.%s.%s", orgName, "ecdlog"))
 	h1X, _ := new(big.Int).SetString(org["h1x"].(string), 10)
 	h1Y, _ := new(big.Int).SetString(org["h1y"].(string), 10)
 	h2X, _ := new(big.Int).SetString(org["h2x"].(string), 10)
 	h2Y, _ := new(big.Int).SetString(org["h2y"].(string), 10)
-	return h1X, h1Y, h2X, h2Y
+	return pseudonymsys.NewPubKeyEC(
+		groups.NewECGroupElement(h1X, h1Y),
+		groups.NewECGroupElement(h2X, h2Y),
+	)
 }
 
 func LoadPseudonymsysCASecret() *big.Int {
@@ -167,11 +171,11 @@ func LoadPseudonymsysCASecret() *big.Int {
 	return s
 }
 
-func LoadPseudonymsysCAPubKey() (*big.Int, *big.Int) {
+func LoadPseudonymsysCAPubKey() *pseudonymsys.PubKey {
 	ca := viper.GetStringMap("pseudonymsys.ca")
 	x, _ := new(big.Int).SetString(ca["x"].(string), 10)
 	y, _ := new(big.Int).SetString(ca["y1"].(string), 10)
-	return x, y
+	return pseudonymsys.NewPubKey(x, y)
 }
 
 func LoadServiceInfo() (string, string, string) {

crypto/zkp/schemes/pseudonymsys/ca.go

@@ -52,9 +52,9 @@ func NewCACertificate(blindedA, blindedB, r, s *big.Int) *CACertificate {
 	}
 }
 
-func NewCA(group *groups.SchnorrGroup, d, x, y *big.Int) *CA {
+func NewCA(group *groups.SchnorrGroup, d *big.Int, caPubKey *PubKey) *CA {
 	c := groups.GetEllipticCurve(groups.P256)
-	pubKey := ecdsa.PublicKey{Curve: c, X: x, Y: y}
+	pubKey := ecdsa.PublicKey{Curve: c, X: caPubKey.H1, Y: caPubKey.H2}
 	privateKey := ecdsa.PrivateKey{PublicKey: pubKey, D: d}
 
 	schnorrVerifier := dlogproofs.NewSchnorrVerifier(group, protocoltypes.Sigma)

crypto/zkp/schemes/pseudonymsys/ca_ec.go

@@ -53,9 +53,9 @@ func NewCACertificateEC(blindedA, blindedB *groups.ECGroupElement, r, s *big.Int
 	}
 }
 
-func NewCAEC(d, x, y *big.Int, curveType groups.ECurve) *CAEC {
+func NewCAEC(d *big.Int, caPubKey *PubKey, curveType groups.ECurve) *CAEC {
 	c := groups.GetEllipticCurve(curveType)
-	pubKey := ecdsa.PublicKey{Curve: c, X: x, Y: y}
+	pubKey := ecdsa.PublicKey{Curve: c, X: caPubKey.H1, Y: caPubKey.H2}
 	privateKey := ecdsa.PrivateKey{PublicKey: pubKey, D: d}
 
 	schnorrVerifier := dlogproofs.NewSchnorrECVerifier(curveType, protocoltypes.Sigma)

crypto/zkp/schemes/pseudonymsys/keygen.go

@@ -24,27 +24,48 @@ import (
 	"github.com/xlab-si/emmy/crypto/groups"
 )
 
+type SecKey struct {
+	S1, S2 *big.Int
+}
+
+func NewSecKey(s1, s2 *big.Int) *SecKey {
+	return &SecKey{s1, s2}
+}
+
+type PubKey struct {
+	H1, H2 *big.Int
+}
+
+func NewPubKey(h1, h2 *big.Int) *PubKey {
+	return &PubKey{h1, h2}
+}
+
+type PubKeyEC struct {
+	H1, H2 *groups.ECGroupElement
+}
+
+func NewPubKeyEC(h1, h2 *groups.ECGroupElement) *PubKeyEC {
+	return &PubKeyEC{h1, h2}
+}
+
 // GenerateKeyPair takes a schnorr group and constructs a pair of secret and public key for
 // pseudonym system scheme.
-// TODO return (SecKey, PubKey) instead
-func GenerateKeyPair(group *groups.SchnorrGroup) (*big.Int, *big.Int, *big.Int, *big.Int) {
+func GenerateKeyPair(group *groups.SchnorrGroup) (*SecKey, *PubKey) {
 	s1 := common.GetRandomInt(group.Q)
 	s2 := common.GetRandomInt(group.Q)
 	h1 := group.Exp(group.G, s1)
 	h2 := group.Exp(group.G, s2)
 
-	return s1, s2, h1, h2
+	return NewSecKey(s1, s2), NewPubKey(h1, h2)
 }
 
 // GenerateECKeyPair takes EC group and constructs a public key for pseudonym system scheme in EC
 // arithmetic.
-// TODO return (SecKey, PubKeyEC) instead
-func GenerateECKeyPair(group *groups.ECGroup) (*big.Int, *big.Int, *groups.ECGroupElement,
-	*groups.ECGroupElement) {
+func GenerateECKeyPair(group *groups.ECGroup) (*SecKey, *PubKeyEC) {
 	s1 := common.GetRandomInt(group.Q)
 	s2 := common.GetRandomInt(group.Q)
 	h1 := group.ExpBaseG(s1)
 	h2 := group.ExpBaseG(s2)
 
-	return s1, s2, h1, h2
+	return NewSecKey(s1, s2), NewPubKeyEC(h1, h2)
 }