Add SignatureV2 infrastructure

CHANGELOG.md

@@ -138,6 +138,7 @@ be used to retrieve the actual proposal `Content`. Also the `NewMsgSubmitProposa
 * (types) [\#6327](https://github.com/cosmos/cosmos-sdk/pull/6327) `sdk.Msg` now inherits `proto.Message`, as a result all `sdk.Msg` types now use pointer semantics.
 * (codec) [\#6330](https://github.com/cosmos/cosmos-sdk/pull/6330) `codec.RegisterCrypto` has been moved to the `crypto/codec` package and the global `codec.Cdc` Amino instance has been deprecated and moved to the `codec/legacy_global` package. 
 * (x/ibc) [\#6374](https://github.com/cosmos/cosmos-sdk/pull/6374) `VerifyMembership` and `VerifyNonMembership` now take a `specs []string` argument to specify the proof format used for verification. Most SDK chains can simply use `commitmenttypes.GetSDKSpecs()` for this argument.
+* (crypto/types/multisig) [\#6373](https://github.com/cosmos/cosmos-sdk/pull/6373) `multisig.Multisignature` has been renamed  to `AminoMultisignature`
 
 ### Features
 

crypto/types/multisig/codec.go

@@ -1,7 +1,7 @@
 package multisig
 
 import (
-	amino "github.com/tendermint/go-amino"
+	"github.com/tendermint/go-amino"
 
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
@@ -10,21 +10,21 @@ import (
 )
 
 // TODO: Figure out API for others to either add their own pubkey types, or
-// to make verify / marshal accept a cdc.
+// to make verify / marshal accept a Cdc.
 const (
 	PubKeyAminoRoute = "tendermint/PubKeyMultisigThreshold"
 )
 
-var cdc = amino.NewCodec()
+var Cdc = amino.NewCodec()
 
 func init() {
-	cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
-	cdc.RegisterConcrete(PubKeyMultisigThreshold{},
+	Cdc.RegisterInterface((*crypto.PubKey)(nil), nil)
+	Cdc.RegisterConcrete(PubKeyMultisigThreshold{},
 		PubKeyAminoRoute, nil)
-	cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
+	Cdc.RegisterConcrete(ed25519.PubKeyEd25519{},
 		ed25519.PubKeyAminoName, nil)
-	cdc.RegisterConcrete(sr25519.PubKeySr25519{},
+	Cdc.RegisterConcrete(sr25519.PubKeySr25519{},
 		sr25519.PubKeyAminoName, nil)
-	cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
+	Cdc.RegisterConcrete(secp256k1.PubKeySecp256k1{},
 		secp256k1.PubKeyAminoName, nil)
 }

crypto/types/multisig/multisignature.go

@@ -7,20 +7,23 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 
 	"github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
 )
 
-// Multisignature is used to represent the signature object used in the multisigs.
+// AminoMultisignature is used to represent amino multi-signatures for StdTx's.
+// It is assumed that all signatures were made with SIGN_MODE_LEGACY_AMINO_JSON.
 // Sigs is a list of signatures, sorted by corresponding index.
-type Multisignature struct {
+type AminoMultisignature struct {
 	BitArray *types.CompactBitArray
 	Sigs     [][]byte
 }
 
-// NewMultisig returns a new Multisignature of size n.
-func NewMultisig(n int) *Multisignature {
-	// Default the signature list to have a capacity of two, since we can
-	// expect that most multisigs will require multiple signers.
-	return &Multisignature{types.NewCompactBitArray(n), make([][]byte, 0, 2)}
+// NewMultisig returns a new MultiSignatureData
+func NewMultisig(n int) *signing.MultiSignatureData {
+	return &signing.MultiSignatureData{
+		BitArray:   types.NewCompactBitArray(n),
+		Signatures: make([]signing.SignatureData, 0, n),
+	}
 }
 
 // GetIndex returns the index of pk in keys. Returns -1 if not found
@@ -35,29 +38,39 @@ func getIndex(pk crypto.PubKey, keys []crypto.PubKey) int {
 
 // AddSignature adds a signature to the multisig, at the corresponding index.
 // If the signature already exists, replace it.
-func (mSig *Multisignature) AddSignature(sig []byte, index int) {
+func AddSignature(mSig *signing.MultiSignatureData, sig signing.SignatureData, index int) {
 	newSigIndex := mSig.BitArray.NumTrueBitsBefore(index)
 	// Signature already exists, just replace the value there
 	if mSig.BitArray.GetIndex(index) {
-		mSig.Sigs[newSigIndex] = sig
+		mSig.Signatures[newSigIndex] = sig
 		return
 	}
 	mSig.BitArray.SetIndex(index, true)
 	// Optimization if the index is the greatest index
-	if newSigIndex == len(mSig.Sigs) {
-		mSig.Sigs = append(mSig.Sigs, sig)
+	if newSigIndex == len(mSig.Signatures) {
+		mSig.Signatures = append(mSig.Signatures, sig)
 		return
 	}
 	// Expand slice by one with a dummy element, move all elements after i
 	// over by one, then place the new signature in that gap.
-	mSig.Sigs = append(mSig.Sigs, make([]byte, 0))
-	copy(mSig.Sigs[newSigIndex+1:], mSig.Sigs[newSigIndex:])
-	mSig.Sigs[newSigIndex] = sig
+	mSig.Signatures = append(mSig.Signatures, &signing.SingleSignatureData{})
+	copy(mSig.Signatures[newSigIndex+1:], mSig.Signatures[newSigIndex:])
+	mSig.Signatures[newSigIndex] = sig
 }
 
 // AddSignatureFromPubKey adds a signature to the multisig, at the index in
 // keys corresponding to the provided pubkey.
-func (mSig *Multisignature) AddSignatureFromPubKey(sig []byte, pubkey crypto.PubKey, keys []crypto.PubKey) error {
+func AddSignatureFromPubKey(mSig *signing.MultiSignatureData, sig signing.SignatureData, pubkey crypto.PubKey, keys []crypto.PubKey) error {
+	if mSig == nil {
+		return fmt.Errorf("value of mSig is nil %v", mSig)
+	}
+	if sig == nil {
+		return fmt.Errorf("value of sig is nil %v", sig)
+	}
+
+	if pubkey == nil || keys == nil {
+		return fmt.Errorf("pubkey or keys can't be nil %v %v", pubkey, keys)
+	}
 	index := getIndex(pubkey, keys)
 	if index == -1 {
 		keysStr := make([]string, len(keys))
@@ -68,11 +81,10 @@ func (mSig *Multisignature) AddSignatureFromPubKey(sig []byte, pubkey crypto.Pub
 		return fmt.Errorf("provided key %X doesn't exist in pubkeys: \n%s", pubkey.Bytes(), strings.Join(keysStr, "\n"))
 	}
 
-	mSig.AddSignature(sig, index)
+	AddSignature(mSig, sig, index)
 	return nil
 }
 
-// Marshal the multisignature with amino
-func (mSig *Multisignature) Marshal() []byte {
-	return cdc.MustMarshalBinaryBare(mSig)
+func AddSignatureV2(mSig *signing.MultiSignatureData, sig signing.SignatureV2, keys []crypto.PubKey) error {
+	return AddSignatureFromPubKey(mSig, sig.Data, sig.PubKey, keys)
 }

crypto/types/multisig/pubkey.go

@@ -0,0 +1,25 @@
+package multisig
+
+import (
+	"github.com/tendermint/tendermint/crypto"
+
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
+)
+
+// PubKey defines a type which supports multi-signature verification via MultiSignatureData
+// which supports multiple SignMode's.
+type PubKey interface {
+	crypto.PubKey
+
+	// VerifyMultisignature verifies the provide multi-signature represented by MultiSignatureData
+	// using getSignBytes to retrieve the sign bytes to verify against for the provided mode.
+	VerifyMultisignature(getSignBytes GetSignBytesFunc, sig *signing.MultiSignatureData) error
+
+	// GetPubKeys returns the crypto.PubKey's nested within the multi-sig PubKey
+	GetPubKeys() []crypto.PubKey
+}
+
+// GetSignBytesFunc defines a function type which returns sign bytes for a given SignMode or an error.
+// It will generally be implemented as a closure which wraps whatever signable object signatures are
+// being verified against.
+type GetSignBytesFunc func(mode signing.SignMode) ([]byte, error)

crypto/types/multisig/threshold_pubkey.go

@@ -1,7 +1,11 @@
 package multisig
 
 import (
+	"fmt"
+
 	"github.com/tendermint/tendermint/crypto"
+
+	"github.com/cosmos/cosmos-sdk/types/tx/signing"
 )
 
 // PubKeyMultisigThreshold implements a K of N threshold multisig.
@@ -10,11 +14,11 @@ type PubKeyMultisigThreshold struct {
 	PubKeys []crypto.PubKey `json:"pubkeys"`
 }
 
-var _ crypto.PubKey = PubKeyMultisigThreshold{}
+var _ PubKey = PubKeyMultisigThreshold{}
 
 // NewPubKeyMultisigThreshold returns a new PubKeyMultisigThreshold.
 // Panics if len(pubkeys) < k or 0 >= k.
-func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
+func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) PubKey {
 	if k <= 0 {
 		panic("threshold k of n multisignature: k <= 0")
 	}
@@ -35,9 +39,12 @@ func NewPubKeyMultisigThreshold(k int, pubkeys []crypto.PubKey) crypto.PubKey {
 // and all signatures are valid. (Not just k of the signatures)
 // The multisig uses a bitarray, so multiple signatures for the same key is not
 // a concern.
+//
+// NOTE: VerifyMultisignature should preferred to VerifyBytes which only works
+// with amino multisignatures.
 func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte) bool {
-	var sig Multisignature
-	err := cdc.UnmarshalBinaryBare(marshalledSig, &sig)
+	var sig AminoMultisignature
+	err := Cdc.UnmarshalBinaryBare(marshalledSig, &sig)
 	if err != nil {
 		return false
 	}
@@ -67,12 +74,65 @@ func (pk PubKeyMultisigThreshold) VerifyBytes(msg []byte, marshalledSig []byte)
 	return true
 }
 
+// VerifyMultisignature implements the PubKey.VerifyMultisignature method
+func (pk PubKeyMultisigThreshold) VerifyMultisignature(getSignBytes GetSignBytesFunc, sig *signing.MultiSignatureData) error {
+	bitarray := sig.BitArray
+	sigs := sig.Signatures
+	size := bitarray.Size()
+	// ensure bit array is the correct size
+	if len(pk.PubKeys) != size {
+		return fmt.Errorf("bit array size is incorrect %d", len(pk.PubKeys))
+	}
+	// ensure size of signature list
+	if len(sigs) < int(pk.K) || len(sigs) > size {
+		return fmt.Errorf("signature size is incorrect %d", len(sigs))
+	}
+	// ensure at least k signatures are set
+	if bitarray.NumTrueBitsBefore(size) < int(pk.K) {
+		return fmt.Errorf("minimum number of signatures not set, have %d, expected %d", bitarray.NumTrueBitsBefore(size), int(pk.K))
+	}
+	// index in the list of signatures which we are concerned with.
+	sigIndex := 0
+	for i := 0; i < size; i++ {
+		if bitarray.GetIndex(i) {
+			si := sig.Signatures[sigIndex]
+			switch si := si.(type) {
+			case *signing.SingleSignatureData:
+				msg, err := getSignBytes(si.SignMode)
+				if err != nil {
+					return err
+				}
+				if !pk.PubKeys[i].VerifyBytes(msg, si.Signature) {
+					return err
+				}
+			case *signing.MultiSignatureData:
+				nestedMultisigPk, ok := pk.PubKeys[i].(PubKey)
+				if !ok {
+					return fmt.Errorf("unable to parse pubkey of index %d", i)
+				}
+				if err := nestedMultisigPk.VerifyMultisignature(getSignBytes, si); err != nil {
+					return err
+				}
+			default:
+				return fmt.Errorf("improper signature data type for index %d", sigIndex)
+			}
+			sigIndex++
+		}
+	}
+	return nil
+}
+
+// GetPubKeys implements the PubKey.GetPubKeys method
+func (pk PubKeyMultisigThreshold) GetPubKeys() []crypto.PubKey {
+	return pk.PubKeys
+}
+
 // Bytes returns the amino encoded version of the PubKeyMultisigThreshold
 func (pk PubKeyMultisigThreshold) Bytes() []byte {
-	return cdc.MustMarshalBinaryBare(pk)
+	return Cdc.MustMarshalBinaryBare(pk)
 }
 
-// Address returns tmhash(PubKey.Bytes())
+// Address returns tmhash(PubKeyMultisigThreshold.Bytes())
 func (pk PubKeyMultisigThreshold) Address() crypto.Address {
 	return crypto.AddressHash(pk.Bytes())
 }