github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/crypto/keys/mintkey/mintkey_test.go (about)

     1  package mintkey_test
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"io"
     7  	"testing"
     8  
     9  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto/armor"
    10  	cryptoAmino "github.com/fibonacci-chain/fbc/libs/tendermint/crypto/encoding/amino"
    11  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto/secp256k1"
    12  	"github.com/stretchr/testify/require"
    13  
    14  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/crypto/keys"
    15  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/crypto/keys/mintkey"
    16  )
    17  
    18  func TestArmorUnarmorPrivKey(t *testing.T) {
    19  	priv := secp256k1.GenPrivKey()
    20  	armor := mintkey.EncryptArmorPrivKey(priv, "passphrase", "")
    21  	_, _, err := mintkey.UnarmorDecryptPrivKey(armor, "wrongpassphrase")
    22  	require.Error(t, err)
    23  	decrypted, algo, err := mintkey.UnarmorDecryptPrivKey(armor, "passphrase")
    24  	require.NoError(t, err)
    25  	require.Equal(t, string(keys.Secp256k1), algo)
    26  	require.True(t, priv.Equals(decrypted))
    27  }
    28  
    29  func TestArmorUnarmorPubKey(t *testing.T) {
    30  	// Select the encryption and storage for your cryptostore
    31  	cstore := keys.NewInMemory()
    32  
    33  	// Add keys and see they return in alphabetical order
    34  	info, _, err := cstore.CreateMnemonic("Bob", keys.English, "passphrase", keys.Secp256k1, "")
    35  	require.NoError(t, err)
    36  	armored := mintkey.ArmorPubKeyBytes(info.GetPubKey().Bytes(), "")
    37  	pubBytes, algo, err := mintkey.UnarmorPubKeyBytes(armored)
    38  	require.NoError(t, err)
    39  	pub, err := cryptoAmino.PubKeyFromBytes(pubBytes)
    40  	require.NoError(t, err)
    41  	require.Equal(t, string(keys.Secp256k1), algo)
    42  	require.True(t, pub.Equals(info.GetPubKey()))
    43  
    44  	armored = mintkey.ArmorPubKeyBytes(info.GetPubKey().Bytes(), "unknown")
    45  	pubBytes, algo, err = mintkey.UnarmorPubKeyBytes(armored)
    46  	require.NoError(t, err)
    47  	pub, err = cryptoAmino.PubKeyFromBytes(pubBytes)
    48  	require.NoError(t, err)
    49  	require.Equal(t, "unknown", algo)
    50  	require.True(t, pub.Equals(info.GetPubKey()))
    51  
    52  	armored, err = cstore.ExportPrivKey("Bob", "passphrase", "alessio")
    53  	require.NoError(t, err)
    54  	_, _, err = mintkey.UnarmorPubKeyBytes(armored)
    55  	require.Equal(t, `couldn't unarmor bytes: unrecognized armor type "TENDERMINT PRIVATE KEY", expected: "TENDERMINT PUBLIC KEY"`, err.Error())
    56  
    57  	// armor pubkey manually
    58  	header := map[string]string{
    59  		"version": "0.0.0",
    60  		"type":    "unknown",
    61  	}
    62  	armored = armor.EncodeArmor("TENDERMINT PUBLIC KEY", header, pubBytes)
    63  	_, algo, err = mintkey.UnarmorPubKeyBytes(armored)
    64  	require.NoError(t, err)
    65  	// return secp256k1 if version is 0.0.0
    66  	require.Equal(t, "secp256k1", algo)
    67  
    68  	// missing version header
    69  	header = map[string]string{
    70  		"type": "unknown",
    71  	}
    72  	armored = armor.EncodeArmor("TENDERMINT PUBLIC KEY", header, pubBytes)
    73  	bz, algo, err := mintkey.UnarmorPubKeyBytes(armored)
    74  	require.Nil(t, bz)
    75  	require.Empty(t, algo)
    76  	require.Error(t, err)
    77  	require.Equal(t, "header's version field is empty", err.Error())
    78  
    79  	// unknown version header
    80  	header = map[string]string{
    81  		"type":    "unknown",
    82  		"version": "unknown",
    83  	}
    84  	armored = armor.EncodeArmor("TENDERMINT PUBLIC KEY", header, pubBytes)
    85  	bz, algo, err = mintkey.UnarmorPubKeyBytes(armored)
    86  	require.Nil(t, bz)
    87  	require.Empty(t, algo)
    88  	require.Error(t, err)
    89  	require.Equal(t, "unrecognized version: unknown", err.Error())
    90  }
    91  
    92  func TestArmorInfoBytes(t *testing.T) {
    93  	bs := []byte("test")
    94  	armoredString := mintkey.ArmorInfoBytes(bs)
    95  	unarmoredBytes, err := mintkey.UnarmorInfoBytes(armoredString)
    96  	require.NoError(t, err)
    97  	require.True(t, bytes.Equal(bs, unarmoredBytes))
    98  }
    99  
   100  func TestUnarmorInfoBytesErrors(t *testing.T) {
   101  	unarmoredBytes, err := mintkey.UnarmorInfoBytes("")
   102  	require.Error(t, err)
   103  	require.True(t, errors.Is(io.EOF, err))
   104  	require.Nil(t, unarmoredBytes)
   105  
   106  	header := map[string]string{
   107  		"type":    "Info",
   108  		"version": "0.0.1",
   109  	}
   110  	unarmoredBytes, err = mintkey.UnarmorInfoBytes(armor.EncodeArmor(
   111  		"TENDERMINT KEY INFO", header, []byte("plain-text")))
   112  	require.Error(t, err)
   113  	require.Equal(t, "unrecognized version: 0.0.1", err.Error())
   114  	require.Nil(t, unarmoredBytes)
   115  }