Implement private keys export/import symmetric functionalities

Ref #2020

client/keys/export.go

@@ -0,0 +1,43 @@
+package keys
+
+import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/client/input"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/mintkey"
+	"github.com/spf13/cobra"
+)
+
+func exportKeyCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "export <name>",
+		Short: "Export private keys",
+		Long:  `Export a private key from the local keybase in ASCII armor format.`,
+		Args:  cobra.ExactArgs(1),
+		RunE:  runExportCmd,
+	}
+	return cmd
+}
+
+func runExportCmd(_ *cobra.Command, args []string) error {
+	kb, err := NewKeyBaseFromHomeFlag()
+	if err != nil {
+		return err
+	}
+
+	buf := input.BufferStdin()
+	encryptPassword, err := input.GetPassword("Enter passphrase to decrypt your key:", buf)
+	if err != nil {
+		return err
+	}
+
+	priv, err := kb.ExportPrivateKeyObject(args[0], encryptPassword)
+	if err != nil {
+		return err
+	}
+
+	armored := mintkey.EncryptArmorPrivKey(priv, encryptPassword)
+	fmt.Println(armored)
+
+	return nil
+}

client/keys/import.go

@@ -0,0 +1,39 @@
+package keys
+
+import (
+	"io/ioutil"
+
+	"github.com/cosmos/cosmos-sdk/client/input"
+	"github.com/spf13/cobra"
+)
+
+func importKeyCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "import <name> <keyfile>",
+		Short: "Import private keys into the local keybase",
+		Long:  "Import a ASCII armored private key into the local keybase.",
+		Args:  cobra.ExactArgs(2),
+		RunE:  runImportCmd,
+	}
+	return cmd
+}
+
+func runImportCmd(_ *cobra.Command, args []string) error {
+	kb, err := NewKeyBaseFromHomeFlag()
+	if err != nil {
+		return err
+	}
+
+	bz, err := ioutil.ReadFile(args[1])
+	if err != nil {
+		return err
+	}
+
+	buf := input.BufferStdin()
+	passphrase, err := input.GetPassword("Enter passphrase to decrypt your key:", buf)
+	if err != nil {
+		return err
+	}
+
+	return kb.ImportPrivKey(args[0], string(bz), passphrase)
+}

client/keys/root.go

@@ -21,6 +21,8 @@ func Commands() *cobra.Command {
 	cmd.AddCommand(
 		mnemonicKeyCommand(),
 		addKeyCommand(),
+		exportKeyCommand(),
+		importKeyCommand(),
 		listKeysCmd(),
 		showKeysCmd(),
 		flags.LineBreak,

crypto/keys/keybase.go

@@ -336,6 +336,20 @@ func (kb dbKeybase) ExportPubKey(name string) (armor string, err error) {
 	return mintkey.ArmorPubKeyBytes(info.GetPubKey().Bytes()), nil
 }
 
+func (kb dbKeybase) ImportPrivKey(name string, armor string, passphrase string) error {
+	if _, err := kb.Get(name); err == nil {
+		return errors.New("Cannot overwrite key " + name)
+	}
+
+	privKey, err := mintkey.UnarmorDecryptPrivKey(armor, passphrase)
+	if err != nil {
+		return errors.Wrap(err, "couldn't import private key")
+	}
+
+	kb.writeLocalKey(name, privKey, passphrase)
+	return nil
+}
+
 func (kb dbKeybase) Import(name string, armor string) (err error) {
 	bz := kb.db.Get(infoKey(name))
 	if len(bz) > 0 {

crypto/keys/lazy_keybase.go

@@ -156,6 +156,16 @@ func (lkb lazyKeybase) Import(name string, armor string) (err error) {
 	return newDbKeybase(db).Import(name, armor)
 }
 
+func (lkb lazyKeybase) ImportPrivKey(name string, armor string, passphrase string) error {
+	db, err := sdk.NewLevelDB(lkb.name, lkb.dir)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	return newDbKeybase(db).ImportPrivKey(name, armor, passphrase)
+}
+
 func (lkb lazyKeybase) ImportPubKey(name string, armor string) (err error) {
 	db, err := sdk.NewLevelDB(lkb.name, lkb.dir)
 	if err != nil {

crypto/keys/types.go

@@ -46,6 +46,7 @@ type Keybase interface {
 	// The following operations will *only* work on locally-stored keys
 	Update(name, oldpass string, getNewpass func() (string, error)) error
 	Import(name string, armor string) (err error)
+	ImportPrivKey(name string, armor string, passphrase string) error
 	ImportPubKey(name string, armor string) (err error)
 	Export(name string) (armor string, err error)
 	ExportPubKey(name string) (armor string, err error)