github.com/Finschia/finschia-sdk@v0.48.1/crypto/keys/secp256r1/privkey_internal_test.go (about)

     1  package secp256r1
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/gogo/protobuf/proto"
     7  	"github.com/stretchr/testify/suite"
     8  
     9  	"github.com/Finschia/finschia-sdk/codec"
    10  	"github.com/Finschia/finschia-sdk/codec/types"
    11  	cryptotypes "github.com/Finschia/finschia-sdk/crypto/types"
    12  	"github.com/Finschia/ostracon/crypto"
    13  )
    14  
    15  var _ cryptotypes.PrivKey = &PrivKey{}
    16  
    17  func TestSKSuite(t *testing.T) {
    18  	suite.Run(t, new(SKSuite))
    19  }
    20  
    21  type SKSuite struct{ CommonSuite }
    22  
    23  func (suite *SKSuite) TestString() {
    24  	suite.Require().Equal("secp256r1{-}", suite.sk.String())
    25  }
    26  
    27  func (suite *SKSuite) TestEquals() {
    28  	require := suite.Require()
    29  
    30  	skOther, err := GenPrivKey()
    31  	require.NoError(err)
    32  	require.False(suite.sk.Equals(skOther))
    33  
    34  	skOther2 := &PrivKey{skOther.Secret}
    35  	require.True(skOther.Equals(skOther2))
    36  	require.True(skOther2.Equals(skOther), "Equals must be reflexive")
    37  }
    38  
    39  func (suite *SKSuite) TestPubKey() {
    40  	pk := suite.sk.PubKey()
    41  	suite.True(suite.sk.(*PrivKey).Secret.PublicKey.Equal(&pk.(*PubKey).Key.PublicKey))
    42  }
    43  
    44  func (suite *SKSuite) TestBytes() {
    45  	bz := suite.sk.Bytes()
    46  	suite.Len(bz, fieldSize)
    47  	var sk *PrivKey
    48  	suite.Nil(sk.Bytes())
    49  }
    50  
    51  func (suite *SKSuite) TestMarshalProto() {
    52  	require := suite.Require()
    53  
    54  	/**** test structure marshalling ****/
    55  
    56  	var sk PrivKey
    57  	bz, err := proto.Marshal(suite.sk)
    58  	require.NoError(err)
    59  	require.NoError(proto.Unmarshal(bz, &sk))
    60  	require.True(sk.Equals(suite.sk))
    61  
    62  	/**** test structure marshalling with codec ****/
    63  
    64  	sk = PrivKey{}
    65  	registry := types.NewInterfaceRegistry()
    66  	cdc := codec.NewProtoCodec(registry)
    67  	bz, err = cdc.Marshal(suite.sk.(*PrivKey))
    68  	require.NoError(err)
    69  	require.NoError(cdc.Unmarshal(bz, &sk))
    70  	require.True(sk.Equals(suite.sk))
    71  
    72  	const bufSize = 100
    73  	bz2 := make([]byte, bufSize)
    74  	skCpy := suite.sk.(*PrivKey)
    75  	_, err = skCpy.MarshalTo(bz2)
    76  	require.NoError(err)
    77  	require.Len(bz2, bufSize)
    78  	require.Equal(bz, bz2[:sk.Size()])
    79  
    80  	bz2 = make([]byte, bufSize)
    81  	_, err = skCpy.MarshalToSizedBuffer(bz2)
    82  	require.NoError(err)
    83  	require.Len(bz2, bufSize)
    84  	require.Equal(bz, bz2[(bufSize-sk.Size()):])
    85  }
    86  
    87  func (suite *SKSuite) TestSign() {
    88  	require := suite.Require()
    89  
    90  	msg := crypto.CRandBytes(1000)
    91  	sig, err := suite.sk.Sign(msg)
    92  	require.NoError(err)
    93  	sigCpy := make([]byte, len(sig))
    94  	copy(sigCpy, sig)
    95  	require.True(suite.pk.VerifySignature(msg, sigCpy))
    96  
    97  	// Mutate the signature
    98  	for i := range sig {
    99  		sigCpy[i] ^= byte(i + 1)
   100  		require.False(suite.pk.VerifySignature(msg, sigCpy))
   101  	}
   102  
   103  	// Mutate the message
   104  	msg[1] ^= byte(2)
   105  	require.False(suite.pk.VerifySignature(msg, sig))
   106  }
   107  
   108  func (suite *SKSuite) TestSize() {
   109  	require := suite.Require()
   110  	var pk ecdsaSK
   111  	require.Equal(pk.Size(), len(suite.sk.Bytes()))
   112  
   113  	var nilPk *ecdsaSK
   114  	require.Equal(0, nilPk.Size(), "nil value must have zero size")
   115  }