vendor/github.com/tendermint/go-crypto/keys/cryptostore/encoder_test.go

   1 package cryptostore_test
   2
   3 import (
   4         "testing"
   5
   6         "github.com/stretchr/testify/assert"
   7         "github.com/stretchr/testify/require"
   8
   9         cmn "github.com/tendermint/tmlibs/common"
  10
  11         "github.com/tendermint/go-crypto/keys/cryptostore"
  12 )
  13
  14 func TestNoopEncoder(t *testing.T) {
  15         assert, require := assert.New(t), require.New(t)
  16         noop := cryptostore.Noop
  17
  18         key, err := cryptostore.GenEd25519.Generate(cmn.RandBytes(16))
  19         require.NoError(err)
  20         key2, err := cryptostore.GenSecp256k1.Generate(cmn.RandBytes(16))
  21         require.NoError(err)
  22
  23         b, err := noop.Encrypt(key, "encode")
  24         require.Nil(err)
  25         assert.NotEmpty(b)
  26
  27         b2, err := noop.Encrypt(key2, "encode")
  28         require.Nil(err)
  29         assert.NotEmpty(b2)
  30         assert.NotEqual(b, b2)
  31
  32         // note the decode with a different password works - not secure!
  33         pk, err := noop.Decrypt(b, "decode")
  34         require.Nil(err)
  35         require.NotNil(pk)
  36         assert.Equal(key, pk)
  37
  38         pk2, err := noop.Decrypt(b2, "kggugougp")
  39         require.Nil(err)
  40         require.NotNil(pk2)
  41         assert.Equal(key2, pk2)
  42 }
  43
  44 func TestSecretBox(t *testing.T) {
  45         assert, require := assert.New(t), require.New(t)
  46         enc := cryptostore.SecretBox
  47
  48         key, err := cryptostore.GenEd25519.Generate(cmn.RandBytes(16))
  49         require.NoError(err)
  50         pass := "some-special-secret"
  51
  52         b, err := enc.Encrypt(key, pass)
  53         require.Nil(err)
  54         assert.NotEmpty(b)
  55
  56         // decoding with a different pass is an error
  57         pk, err := enc.Decrypt(b, "decode")
  58         require.NotNil(err)
  59         require.True(pk.Empty())
  60
  61         // but decoding with the same passphrase gets us our key
  62         pk, err = enc.Decrypt(b, pass)
  63         require.Nil(err)
  64         assert.Equal(key, pk)
  65 }
  66
  67 func TestSecretBoxNoPass(t *testing.T) {
  68         assert, require := assert.New(t), require.New(t)
  69         enc := cryptostore.SecretBox
  70
  71         key, rerr := cryptostore.GenEd25519.Generate(cmn.RandBytes(16))
  72         require.NoError(rerr)
  73
  74         cases := []struct {
  75                 encode string
  76                 decode string
  77                 valid  bool
  78         }{
  79                 {"foo", "foo", true},
  80                 {"foo", "food", false},
  81                 {"", "", true},
  82                 {"", "a", false},
  83                 {"a", "", false},
  84         }
  85
  86         for i, tc := range cases {
  87                 b, err := enc.Encrypt(key, tc.encode)
  88                 require.Nil(err, "%d: %+v", i, err)
  89                 assert.NotEmpty(b, "%d", i)
  90
  91                 pk, err := enc.Decrypt(b, tc.decode)
  92                 if tc.valid {
  93                         require.Nil(err, "%d: %+v", i, err)
  94                         assert.Equal(key, pk, "%d", i)
  95                 } else {
  96                         require.NotNil(err, "%d", i)
  97                 }
  98         }
  99
 100         // now let's make sure raw bytes also work...
 101         b := key.Bytes()
 102         pk, err := enc.Decrypt(b, "")
 103         require.Nil(err, "%+v", err)
 104         assert.Equal(key, pk)
 105 }