add auth v3 (#92)

* add auth v3

Author: volodymyr-basiuk

auth.go

@@ -24,8 +24,8 @@ type AuthInputs struct {
 	Challenge *big.Int
 }
 
-// authCircuitInputs type reflect auth.circom private inputs required by prover
-type authCircuitInputs struct {
+// authV1CircuitInputs type reflect auth.circom private inputs required by prover
+type authV1CircuitInputs struct {
 	UserAuthClaim               *core.Claim      `json:"userAuthClaim"`
 	UserAuthClaimMtp            []string         `json:"userAuthClaimMtp"`
 	UserAuthClaimNonRevMtp      []string         `json:"userAuthClaimNonRevMtp"`
@@ -58,7 +58,7 @@ func (a AuthInputs) InputsMarshal() ([]byte, error) {
 		return nil, errors.New(ErrorEmptyChallengeSignature)
 	}
 
-	s := authCircuitInputs{
+	s := authV1CircuitInputs{
 		UserAuthClaim: a.AuthClaim.Claim,
 		UserAuthClaimMtp: PrepareSiblingsStr(a.AuthClaim.IncProof.Proof.AllSiblings(),
 			a.GetMTLevel()),

authV2.go

@@ -31,7 +31,7 @@ type AuthV2Inputs struct {
 }
 
 // authCircuitInputs type reflect auth.circom private inputs required by prover
-type authV2CircuitInputs struct {
+type authCircuitInputs struct {
 	// ID
 	GenesisID    string `json:"genesisID"`
 	ProfileNonce string `json:"profileNonce"`
@@ -101,7 +101,7 @@ func (a AuthV2Inputs) InputsMarshal() ([]byte, error) {
 		return nil, err
 	}
 
-	s := authV2CircuitInputs{
+	s := authCircuitInputs{
 		GenesisID:    a.GenesisID.BigInt().String(),
 		ProfileNonce: a.ProfileNonce.String(),
 		AuthClaim:    a.AuthClaim,
@@ -158,7 +158,6 @@ func (a AuthV2Inputs) GetPublicStatesInfo() (StatesInfo, error) {
 	}, nil
 }
 
-
 // AuthV2PubSignals auth.circom public signals
 type AuthV2PubSignals struct {
 	UserID    *core.ID         `json:"userID"`

authV3.go

@@ -0,0 +1,177 @@
+package circuits
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+
+	core "github.com/iden3/go-iden3-core/v2"
+	"github.com/iden3/go-iden3-crypto/babyjub"
+	"github.com/iden3/go-merkletree-sql/v2"
+	"github.com/pkg/errors"
+)
+
+// AuthV3Inputs type represent authV3.circom/authV3-8-32.circom inputs
+type AuthV3Inputs struct {
+	BaseConfig
+
+	GenesisID    *core.ID `json:"genesisID"`
+	ProfileNonce *big.Int `json:"profileNonce"`
+
+	AuthClaim *core.Claim `json:"authClaim"`
+
+	AuthClaimIncMtp    *merkletree.Proof `json:"authClaimIncMtp"`
+	AuthClaimNonRevMtp *merkletree.Proof `json:"authClaimNonRevMtp"`
+	TreeState          TreeState         `json:"treeState"`
+
+	GISTProof GISTProof `json:"gistProof"`
+
+	Signature *babyjub.Signature `json:"signature"`
+	Challenge *big.Int           `json:"challenge"`
+}
+
+func (a AuthV3Inputs) Validate() error {
+
+	if a.GenesisID == nil {
+		return errors.New(ErrorEmptyID)
+	}
+
+	if a.AuthClaimIncMtp == nil {
+		return errors.New(ErrorEmptyAuthClaimProof)
+	}
+
+	if a.AuthClaimNonRevMtp == nil {
+		return errors.New(ErrorEmptyAuthClaimNonRevProof)
+	}
+
+	if a.GISTProof.Proof == nil {
+		return errors.New(ErrorEmptyGISTProof)
+	}
+
+	if a.Signature == nil {
+		return errors.New(ErrorEmptyChallengeSignature)
+	}
+
+	if a.Challenge == nil {
+		return errors.New(ErrorEmptyChallenge)
+	}
+
+	return nil
+}
+
+// InputsMarshal returns Circom private inputs for auth.circom
+func (a AuthV3Inputs) InputsMarshal() ([]byte, error) {
+
+	if err := a.Validate(); err != nil {
+		return nil, err
+	}
+
+	s := authCircuitInputs{
+		GenesisID:    a.GenesisID.BigInt().String(),
+		ProfileNonce: a.ProfileNonce.String(),
+		AuthClaim:    a.AuthClaim,
+		AuthClaimMtp: merkletree.CircomSiblingsFromSiblings(a.AuthClaimIncMtp.AllSiblings(),
+			a.GetMTLevel()-1),
+		AuthClaimNonRevMtp: merkletree.CircomSiblingsFromSiblings(a.AuthClaimNonRevMtp.AllSiblings(),
+			a.GetMTLevel()-1),
+		Challenge:             a.Challenge.String(),
+		ChallengeSignatureR8X: a.Signature.R8.X.String(),
+		ChallengeSignatureR8Y: a.Signature.R8.Y.String(),
+		ChallengeSignatureS:   a.Signature.S.String(),
+		ClaimsTreeRoot:        a.TreeState.ClaimsRoot,
+		RevTreeRoot:           a.TreeState.RevocationRoot,
+		RootsTreeRoot:         a.TreeState.RootOfRoots,
+		State:                 a.TreeState.State,
+		GISTRoot:              a.GISTProof.Root,
+		GISTMtp: merkletree.CircomSiblingsFromSiblings(a.GISTProof.Proof.AllSiblings(),
+			a.GetMTLevelOnChain()-1),
+	}
+
+	nodeAuxAuth := GetNodeAuxValue(a.AuthClaimNonRevMtp)
+	s.AuthClaimNonRevMtpAuxHi = nodeAuxAuth.key
+	s.AuthClaimNonRevMtpAuxHv = nodeAuxAuth.value
+	s.AuthClaimNonRevMtpNoAux = nodeAuxAuth.noAux
+
+	gistNodeAux := GetNodeAuxValue(a.GISTProof.Proof)
+	s.GISTMtpAuxHi = gistNodeAux.key
+	s.GISTMtpAuxHv = gistNodeAux.value
+	s.GISTMtpNoAux = gistNodeAux.noAux
+
+	return json.Marshal(s)
+}
+
+// GetPublicStatesInfo returns states and gists information,
+// implements PublicStatesInfoProvider interface
+func (a AuthV3Inputs) GetPublicStatesInfo() (StatesInfo, error) {
+
+	if err := a.Validate(); err != nil {
+		return StatesInfo{}, err
+	}
+
+	userID, err := core.ProfileID(*a.GenesisID, a.ProfileNonce)
+	if err != nil {
+		return StatesInfo{}, err
+	}
+	return StatesInfo{
+		States: []State{},
+		Gists: []Gist{
+			{
+				ID:   userID,
+				Root: *a.GISTProof.Root,
+			},
+		},
+	}, nil
+}
+
+// AuthV3PubSignals authV3.circom/authV3-8-32.circom public signals
+type AuthV3PubSignals struct {
+	UserID    *core.ID         `json:"userID"`
+	Challenge *big.Int         `json:"challenge"`
+	GISTRoot  *merkletree.Hash `json:"GISTRoot"`
+}
+
+// PubSignalsUnmarshal unmarshal authV3.circom/authV3-8-32.circom public inputs to AuthPubSignals
+func (a *AuthV3PubSignals) PubSignalsUnmarshal(data []byte) error {
+	var sVals []string
+	err := json.Unmarshal(data, &sVals)
+	if err != nil {
+		return err
+	}
+
+	if len(sVals) != 3 {
+		return fmt.Errorf("invalid number of Output values expected {%d} got {%d} ", 3, len(sVals))
+	}
+
+	if a.UserID, err = idFromIntStr(sVals[0]); err != nil {
+		return err
+	}
+
+	var ok bool
+	if a.Challenge, ok = big.NewInt(0).SetString(sVals[1], 10); !ok {
+		return fmt.Errorf("invalid challenge value: '%s'", sVals[0])
+	}
+
+	if a.GISTRoot, err = merkletree.NewHashFromString(sVals[2]); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetObjMap returns AuthPubSignals as a map
+func (a AuthV3PubSignals) GetObjMap() map[string]interface{} {
+	return toMap(a)
+}
+
+func (a AuthV3PubSignals) GetStatesInfo() (StatesInfo, error) {
+	if a.UserID == nil {
+		return StatesInfo{}, errors.New(ErrorEmptyID)
+	}
+	if a.GISTRoot == nil {
+		return StatesInfo{}, errors.New(ErrorEmptyStateHash)
+	}
+	return StatesInfo{
+		States: []State{},
+		Gists:  []Gist{{ID: *a.UserID, Root: *a.GISTRoot}},
+	}, nil
+}

authV3_test.go

@@ -0,0 +1,166 @@
+package circuits
+
+import (
+	"context"
+	"encoding/json"
+	"math/big"
+	"testing"
+
+	it "github.com/iden3/go-circuits/v2/testing"
+	core "github.com/iden3/go-iden3-core/v2"
+	"github.com/iden3/go-merkletree-sql/v2"
+	"github.com/stretchr/testify/require"
+)
+
+func authV3Inputs(t testing.TB, isAuthV3_8_32 bool) AuthV3Inputs {
+	ctx := context.Background()
+	challenge := big.NewInt(10)
+
+	// generate identity
+	user := it.NewIdentity(t, userPK)
+	nonce := big.NewInt(0)
+
+	user2 := it.NewIdentity(t, issuerPK)
+
+	// generate gist tree
+	gTree := it.GISTTree(ctx)
+
+	err := gTree.Add(ctx, user2.ID.BigInt(), user2.State(t).BigInt())
+	require.NoError(t, err)
+
+	// prepare inputs
+	gistProof, _, err := gTree.GenerateProof(ctx, user.ID.BigInt(), nil)
+	require.NoError(t, err)
+
+	authClaimIncMTP, _ := user.ClaimMTPRaw(t, user.AuthClaim)
+
+	authClaimNonRevMTP, _ := user.ClaimRevMTPRaw(t, user.AuthClaim)
+	require.NoError(t, err)
+
+	signature, err := user.SignBBJJ(challenge.Bytes())
+	require.NoError(t, err)
+
+	inputs := AuthV3Inputs{
+		GenesisID:          &user.ID,
+		ProfileNonce:       nonce,
+		AuthClaim:          user.AuthClaim,
+		AuthClaimIncMtp:    authClaimIncMTP,
+		AuthClaimNonRevMtp: authClaimNonRevMTP,
+		TreeState:          GetTreeState(t, user),
+		GISTProof: GISTProof{
+			Root:  gTree.Root(),
+			Proof: gistProof,
+		},
+		Signature: signature,
+		Challenge: challenge,
+	}
+
+	if isAuthV3_8_32 {
+		inputs.BaseConfig = BaseConfig{MTLevel: 8, MTLevelOnChain: 32}
+	}
+	return inputs
+}
+
+func TestAuthV3Inputs_InputsMarshal(t *testing.T) {
+	inputs := authV3Inputs(t, false)
+	circuitInputJSON, err := inputs.InputsMarshal()
+	require.NoError(t, err)
+
+	exp := it.TestData(t, "authV3_inputs", string(circuitInputJSON), *generate)
+	require.JSONEq(t, exp, string(circuitInputJSON))
+}
+
+func TestAuthV3_8_32Inputs_InputsMarshal(t *testing.T) {
+	inputs := authV3Inputs(t, true)
+	circuitInputJSON, err := inputs.InputsMarshal()
+	require.NoError(t, err)
+
+	exp := it.TestData(t, "authV3-8-32_inputs", string(circuitInputJSON), *generate)
+	require.JSONEq(t, exp, string(circuitInputJSON))
+}
+
+func TestAuthV3Inputs_GetPublicStatesInfo(t *testing.T) {
+	inputs := authV3Inputs(t, false)
+	statesInfo, err := inputs.GetPublicStatesInfo()
+	require.NoError(t, err)
+
+	statesInfoJsonBytes, err := json.Marshal(statesInfo)
+	require.NoError(t, err)
+
+	want := `{
+	"states":[],
+	"gists":[
+			{
+			"id":"26109404700696283154998654512117952420503675471097392618762221546565140481",
+			"root":"11098939821764568131087645431296528907277253709936443029379587475821759259406"
+			}
+		]
+	}`
+
+	require.JSONEq(t, want, string(statesInfoJsonBytes))
+}
+
+func TestAuthV3_8_32Inputs_GetPublicStatesInfo(t *testing.T) {
+	inputs := authV3Inputs(t, true)
+	statesInfo, err := inputs.GetPublicStatesInfo()
+	require.NoError(t, err)
+
+	statesInfoJsonBytes, err := json.Marshal(statesInfo)
+	require.NoError(t, err)
+
+	want := `{
+	"states":[],
+	"gists":[
+			{
+			"id":"26109404700696283154998654512117952420503675471097392618762221546565140481",
+			"root":"11098939821764568131087645431296528907277253709936443029379587475821759259406"
+			}
+		]
+	}`
+
+	require.JSONEq(t, want, string(statesInfoJsonBytes))
+}
+
+func TestAuthV3Circuit_CircuitUnmarshal(t *testing.T) {
+	// generate mock Data.
+	intID, b := new(big.Int).SetString("19224224881555258540966250468059781351205177043309252290095510834143232000",
+		10)
+	require.True(t, b)
+	identifier, err := core.IDFromInt(intID)
+	require.NoError(t, err)
+
+	challenge := big.NewInt(1)
+
+	stateInt, b := new(big.Int).SetString(
+		"18656147546666944484453899241916469544090258810192803949522794490493271005313",
+		10)
+	require.True(t, b)
+	state, err := merkletree.NewHashFromBigInt(stateInt)
+	require.NoError(t, err)
+
+	out := []string{identifier.BigInt().String(), challenge.String(), state.BigInt().String()}
+	bytesOut, err := json.Marshal(out)
+	require.NoError(t, err)
+
+	ao := AuthV3PubSignals{}
+	err = ao.PubSignalsUnmarshal(bytesOut)
+	require.NoError(t, err)
+	require.Equal(t, challenge, ao.Challenge)
+	require.Equal(t, state, ao.GISTRoot)
+	require.Equal(t, &identifier, ao.UserID)
+
+	statesInfo, err := ao.GetStatesInfo()
+	require.NoError(t, err)
+	wantStatesInfo := StatesInfo{
+		States: []State{},
+		Gists: []Gist{
+			{
+				ID:   idFromInt("19224224881555258540966250468059781351205177043309252290095510834143232000"),
+				Root: hashFromInt("18656147546666944484453899241916469544090258810192803949522794490493271005313"),
+			},
+		},
+	}
+	j, err := json.Marshal(statesInfo)
+	require.NoError(t, err)
+	require.Equal(t, wantStatesInfo, statesInfo, string(j))
+}