vendor/github.com/tendermint/go-crypto/signature_test.go

   1 package crypto
   2
   3 import (
   4         "strings"
   5         "testing"
   6
   7         "github.com/stretchr/testify/assert"
   8         "github.com/stretchr/testify/require"
   9         "github.com/tendermint/ed25519"
  10         data "github.com/tendermint/go-wire/data"
  11 )
  12
  13 func TestSignAndValidateEd25519(t *testing.T) {
  14
  15         privKey := GenPrivKeyEd25519()
  16         pubKey := privKey.PubKey()
  17
  18         msg := CRandBytes(128)
  19         sig := privKey.Sign(msg)
  20
  21         // Test the signature
  22         assert.True(t, pubKey.VerifyBytes(msg, sig))
  23
  24         // Mutate the signature, just one bit.
  25         sigEd := sig.Unwrap().(SignatureEd25519)
  26         sigEd[7] ^= byte(0x01)
  27         sig = sigEd.Wrap()
  28
  29         assert.False(t, pubKey.VerifyBytes(msg, sig))
  30 }
  31
  32 func TestSignAndValidateSecp256k1(t *testing.T) {
  33         privKey := GenPrivKeySecp256k1()
  34         pubKey := privKey.PubKey()
  35
  36         msg := CRandBytes(128)
  37         sig := privKey.Sign(msg)
  38
  39         assert.True(t, pubKey.VerifyBytes(msg, sig))
  40
  41         // Mutate the signature, just one bit.
  42         sigEd := sig.Unwrap().(SignatureSecp256k1)
  43         sigEd[3] ^= byte(0x01)
  44         sig = sigEd.Wrap()
  45
  46         assert.False(t, pubKey.VerifyBytes(msg, sig))
  47 }
  48
  49 func TestSignatureEncodings(t *testing.T) {
  50         cases := []struct {
  51                 privKey PrivKey
  52                 sigSize int
  53                 sigType byte
  54                 sigName string
  55         }{
  56                 {
  57                         privKey: GenPrivKeyEd25519().Wrap(),
  58                         sigSize: ed25519.SignatureSize,
  59                         sigType: TypeEd25519,
  60                         sigName: NameEd25519,
  61                 },
  62                 {
  63                         privKey: GenPrivKeySecp256k1().Wrap(),
  64                         sigSize: 0, // unknown
  65                         sigType: TypeSecp256k1,
  66                         sigName: NameSecp256k1,
  67                 },
  68         }
  69
  70         for _, tc := range cases {
  71                 // note we embed them from the beginning....
  72                 pubKey := tc.privKey.PubKey()
  73
  74                 msg := CRandBytes(128)
  75                 sig := tc.privKey.Sign(msg)
  76
  77                 // store as wire
  78                 bin, err := data.ToWire(sig)
  79                 require.Nil(t, err, "%+v", err)
  80                 if tc.sigSize != 0 {
  81                         assert.Equal(t, tc.sigSize+1, len(bin))
  82                 }
  83                 assert.Equal(t, tc.sigType, bin[0])
  84
  85                 // and back
  86                 sig2 := Signature{}
  87                 err = data.FromWire(bin, &sig2)
  88                 require.Nil(t, err, "%+v", err)
  89                 assert.EqualValues(t, sig, sig2)
  90                 assert.True(t, pubKey.VerifyBytes(msg, sig2))
  91
  92                 // store as json
  93                 js, err := data.ToJSON(sig)
  94                 require.Nil(t, err, "%+v", err)
  95                 assert.True(t, strings.Contains(string(js), tc.sigName))
  96
  97                 // and back
  98                 sig3 := Signature{}
  99                 err = data.FromJSON(js, &sig3)
 100                 require.Nil(t, err, "%+v", err)
 101                 assert.EqualValues(t, sig, sig3)
 102                 assert.True(t, pubKey.VerifyBytes(msg, sig3))
 103
 104                 // and make sure we can textify it
 105                 text, err := data.ToText(sig)
 106                 require.Nil(t, err, "%+v", err)
 107                 assert.True(t, strings.HasPrefix(text, tc.sigName))
 108         }
 109 }
 110
 111 func TestWrapping(t *testing.T) {
 112         assert := assert.New(t)
 113
 114         // construct some basic constructs
 115         msg := CRandBytes(128)
 116         priv := GenPrivKeyEd25519()
 117         pub := priv.PubKey()
 118         sig := priv.Sign(msg)
 119
 120         // do some wrapping
 121         pubs := []PubKey{
 122                 PubKey{nil},
 123                 pub.Wrap(),
 124                 pub.Wrap().Wrap().Wrap(),
 125                 PubKey{PubKey{PubKey{pub}}}.Wrap(),
 126         }
 127         for _, p := range pubs {
 128                 _, ok := p.PubKeyInner.(PubKey)
 129                 assert.False(ok)
 130         }
 131
 132         sigs := []Signature{
 133                 Signature{nil},
 134                 sig.Wrap(),
 135                 sig.Wrap().Wrap().Wrap(),
 136                 Signature{Signature{Signature{sig}}}.Wrap(),
 137         }
 138         for _, s := range sigs {
 139                 _, ok := s.SignatureInner.(Signature)
 140                 assert.False(ok)
 141         }
 142
 143 }