github.com/lzy4123/fabric@v2.1.1+incompatible/bccsp/idemix/bridge/user.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  package bridge
     7  
     8  import (
     9  	"github.com/hyperledger/fabric-amcl/amcl"
    10  	"github.com/hyperledger/fabric-amcl/amcl/FP256BN"
    11  	"github.com/hyperledger/fabric/bccsp/idemix/handlers"
    12  	cryptolib "github.com/hyperledger/fabric/idemix"
    13  	"github.com/pkg/errors"
    14  )
    15  
    16  // User encapsulates the idemix algorithms to generate user secret keys and pseudonym.
    17  type User struct {
    18  	NewRand func() *amcl.RAND
    19  }
    20  
    21  // NewKey generates an idemix user secret key
    22  func (u *User) NewKey() (res handlers.Big, err error) {
    23  	defer func() {
    24  		if r := recover(); r != nil {
    25  			res = nil
    26  			err = errors.Errorf("failure [%s]", r)
    27  		}
    28  	}()
    29  
    30  	res = &Big{E: cryptolib.RandModOrder(u.NewRand())}
    31  
    32  	return
    33  }
    34  
    35  func (*User) NewKeyFromBytes(raw []byte) (res handlers.Big, err error) {
    36  	if len(raw) != int(FP256BN.MODBYTES) {
    37  		return nil, errors.Errorf("invalid length, expected [%d], got [%d]", FP256BN.MODBYTES, len(raw))
    38  	}
    39  
    40  	res = &Big{E: FP256BN.FromBytes(raw)}
    41  
    42  	return
    43  }
    44  
    45  // MakeNym generates a new pseudonym key-pair derived from the passed user secret key (sk) and issuer public key (ipk)
    46  func (u *User) MakeNym(sk handlers.Big, ipk handlers.IssuerPublicKey) (r1 handlers.Ecp, r2 handlers.Big, err error) {
    47  	defer func() {
    48  		if r := recover(); r != nil {
    49  			r1 = nil
    50  			r2 = nil
    51  			err = errors.Errorf("failure [%s]", r)
    52  		}
    53  	}()
    54  
    55  	isk, ok := sk.(*Big)
    56  	if !ok {
    57  		return nil, nil, errors.Errorf("invalid user secret key, expected *Big, got [%T]", sk)
    58  	}
    59  	iipk, ok := ipk.(*IssuerPublicKey)
    60  	if !ok {
    61  		return nil, nil, errors.Errorf("invalid issuer public key, expected *IssuerPublicKey, got [%T]", ipk)
    62  	}
    63  
    64  	ecp, big := cryptolib.MakeNym(isk.E, iipk.PK, u.NewRand())
    65  
    66  	r1 = &Ecp{E: ecp}
    67  	r2 = &Big{E: big}
    68  
    69  	return
    70  }
    71  
    72  func (*User) NewPublicNymFromBytes(raw []byte) (r handlers.Ecp, err error) {
    73  	defer func() {
    74  		if r := recover(); r != nil {
    75  			r = nil
    76  			err = errors.Errorf("failure [%s]", r)
    77  		}
    78  	}()
    79  
    80  	// raw is the concatenation of two big integers
    81  	lHalve := len(raw) / 2
    82  
    83  	r = &Ecp{E: FP256BN.NewECPbigs(FP256BN.FromBytes(raw[:lHalve]), FP256BN.FromBytes(raw[lHalve:]))}
    84  
    85  	return
    86  }