vendor/github.com/tendermint/go-crypto/nano/sign_test.go

   1 package nano
   2
   3 import (
   4         "encoding/hex"
   5         "testing"
   6
   7         "github.com/pkg/errors"
   8         "github.com/stretchr/testify/assert"
   9         "github.com/stretchr/testify/require"
  10         crypto "github.com/tendermint/go-crypto"
  11 )
  12
  13 func parseEdKey(data []byte) (key crypto.PubKey, err error) {
  14         ed := crypto.PubKeyEd25519{}
  15         if len(data) < len(ed) {
  16                 return key, errors.Errorf("Key length too short: %d", len(data))
  17         }
  18         copy(ed[:], data)
  19         return ed.Wrap(), nil
  20 }
  21
  22 func parseSig(data []byte) (key crypto.Signature, err error) {
  23         ed := crypto.SignatureEd25519{}
  24         if len(data) < len(ed) {
  25                 return key, errors.Errorf("Sig length too short: %d", len(data))
  26         }
  27         copy(ed[:], data)
  28         return ed.Wrap(), nil
  29 }
  30
  31 func TestParseDigest(t *testing.T) {
  32         assert, require := assert.New(t), require.New(t)
  33
  34         cases := []struct {
  35                 output string
  36                 key    string
  37                 sig    string
  38                 valid  bool
  39         }{
  40                 {
  41                         output: "80028E8754F012C2FDB492183D41437FD837CB81D8BBE731924E2E0DAF43FD3F2C9300CAFE00787DC03E9E4EE05983E30BAE0DEFB8DB0671DBC2F5874AC93F8D8CA4018F7A42D6F9A9BCEADB422AC8E27CEE9CA205A0B88D22CD686F0A43EB806E8190A3C400",
  42                         key:    "8E8754F012C2FDB492183D41437FD837CB81D8BBE731924E2E0DAF43FD3F2C93",
  43                         sig:    "787DC03E9E4EE05983E30BAE0DEFB8DB0671DBC2F5874AC93F8D8CA4018F7A42D6F9A9BCEADB422AC8E27CEE9CA205A0B88D22CD686F0A43EB806E8190A3C400",
  44                         valid:  true,
  45                 },
  46                 {
  47                         output: "800235467890876543525437890796574535467890",
  48                         key:    "",
  49                         sig:    "",
  50                         valid:  false,
  51                 },
  52         }
  53
  54         for i, tc := range cases {
  55                 msg, err := hex.DecodeString(tc.output)
  56                 require.Nil(err, "%d: %+v", i, err)
  57
  58                 lKey, lSig, err := parseDigest(msg)
  59                 if !tc.valid {
  60                         assert.NotNil(err, "%d", i)
  61                 } else if assert.Nil(err, "%d: %+v", i, err) {
  62                         key, err := hex.DecodeString(tc.key)
  63                         require.Nil(err, "%d: %+v", i, err)
  64                         sig, err := hex.DecodeString(tc.sig)
  65                         require.Nil(err, "%d: %+v", i, err)
  66
  67                         assert.Equal(key, lKey, "%d", i)
  68                         assert.Equal(sig, lSig, "%d", i)
  69                 }
  70         }
  71 }
  72
  73 type cryptoCase struct {
  74         msg   string
  75         key   string
  76         sig   string
  77         valid bool
  78 }
  79
  80 func toBytes(c cryptoCase) (msg, key, sig []byte, err error) {
  81         msg, err = hex.DecodeString(c.msg)
  82         if err != nil {
  83                 return
  84         }
  85         key, err = hex.DecodeString(c.key)
  86         if err != nil {
  87                 return
  88         }
  89         sig, err = hex.DecodeString(c.sig)
  90         return
  91 }
  92
  93 func TestCryptoConvert(t *testing.T) {
  94         assert, require := assert.New(t), require.New(t)
  95
  96         cases := []cryptoCase{
  97                 0: {
  98                         msg:   "F00D",
  99                         key:   "8E8754F012C2FDB492183D41437FD837CB81D8BBE731924E2E0DAF43FD3F2C93",
 100                         sig:   "787DC03E9E4EE05983E30BAE0DEFB8DB0671DBC2F5874AC93F8D8CA4018F7A42D6F9A9BCEADB422AC8E27CEE9CA205A0B88D22CD686F0A43EB806E8190A3C400",
 101                         valid: true,
 102                 },
 103                 1: {
 104                         msg:   "DEADBEEF",
 105                         key:   "0C45ADC887A5463F668533443C829ED13EA8E2E890C778957DC28DB9D2AD5A6C",
 106                         sig:   "00ED74EED8FDAC7988A14BF6BC222120CBAC249D569AF4C2ADABFC86B792F97DF73C4919BE4B6B0ACB53547273BF29FBF0A9E0992FFAB6CB6C9B09311FC86A00",
 107                         valid: true,
 108                 },
 109                 2: {
 110                         msg:   "1234567890AA",
 111                         key:   "598FC1F0C76363D14D7480736DEEF390D85863360F075792A6975EFA149FD7EA",
 112                         sig:   "59AAB7D7BDC4F936B6415DE672A8B77FA6B8B3451CD95B3A631F31F9A05DAEEE5E7E4F89B64DDEBB5F63DC042CA13B8FCB8185F82AD7FD5636FFDA6B0DC9570B",
 113                         valid: true,
 114                 },
 115                 3: {
 116                         msg:   "1234432112344321",
 117                         key:   "359E0636E780457294CCA5D2D84DB190C3EDBD6879729C10D3963DEA1D5D8120",
 118                         sig:   "616B44EC7A65E7C719C170D669A47DE80C6AC0BB13FBCC89230976F9CC14D4CF9ECF26D4AFBB9FFF625599F1FF6F78EDA15E9F6B6BDCE07CFE9D8C407AC45208",
 119                         valid: true,
 120                 },
 121                 4: {
 122                         msg:   "12344321123443",
 123                         key:   "359E0636E780457294CCA5D2D84DB190C3EDBD6879729C10D3963DEA1D5D8120",
 124                         sig:   "616B44EC7A65E7C719C170D669A47DE80C6AC0BB13FBCC89230976F9CC14D4CF9ECF26D4AFBB9FFF625599F1FF6F78EDA15E9F6B6BDCE07CFE9D8C407AC45208",
 125                         valid: false,
 126                 },
 127                 5: {
 128                         msg:   "1234432112344321",
 129                         key:   "459E0636E780457294CCA5D2D84DB190C3EDBD6879729C10D3963DEA1D5D8120",
 130                         sig:   "616B44EC7A65E7C719C170D669A47DE80C6AC0BB13FBCC89230976F9CC14D4CF9ECF26D4AFBB9FFF625599F1FF6F78EDA15E9F6B6BDCE07CFE9D8C407AC45208",
 131                         valid: false,
 132                 },
 133                 6: {
 134                         msg:   "1234432112344321",
 135                         key:   "359E0636E780457294CCA5D2D84DB190C3EDBD6879729C10D3963DEA1D5D8120",
 136                         sig:   "716B44EC7A65E7C719C170D669A47DE80C6AC0BB13FBCC89230976F9CC14D4CF9ECF26D4AFBB9FFF625599F1FF6F78EDA15E9F6B6BDCE07CFE9D8C407AC45208",
 137                         valid: false,
 138                 },
 139         }
 140
 141         for i, tc := range cases {
 142                 msg, key, sig, err := toBytes(tc)
 143                 require.Nil(err, "%d: %+v", i, err)
 144
 145                 pk, err := parseEdKey(key)
 146                 require.Nil(err, "%d: %+v", i, err)
 147                 psig, err := parseSig(sig)
 148                 require.Nil(err, "%d: %+v", i, err)
 149
 150                 // it is not the signature of the message itself
 151                 valid := pk.VerifyBytes(msg, psig)
 152                 assert.False(valid, "%d", i)
 153
 154                 // but rather of the hash of the msg
 155                 hmsg := hashMsg(msg)
 156                 valid = pk.VerifyBytes(hmsg, psig)
 157                 assert.Equal(tc.valid, valid, "%d", i)
 158         }
 159 }