Support for importing unarmored key (secp256k1 algo only at the moment)

client/keys/export.go

@@ -12,8 +12,9 @@ import (
 )
 
 const (
-	flagUnarmoredHex = "unarmored-hex"
-	flagUnsafe       = "unsafe"
+	flagUnarmoredHex     = "unarmored-hex"
+	flagUnarmoredKeyAlgo = "unarmored-key-algo"
+	flagUnsafe           = "unsafe"
 )
 
 // ExportKeyCommand exports private keys from the key store.

client/keys/import.go

@@ -2,6 +2,8 @@ package keys
 
 import (
 	"bufio"
+	"fmt"
+	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -12,7 +14,7 @@ import (
 
 // ImportKeyCommand imports private keys from a keyfile.
 func ImportKeyCommand() *cobra.Command {
-	return &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.",
@@ -29,6 +31,13 @@ func ImportKeyCommand() *cobra.Command {
 				return err
 			}
 
+			unarmored, _ := cmd.Flags().GetBool(flagUnarmoredHex)
+			algo, _ := cmd.Flags().GetString(flagUnarmoredKeyAlgo)
+
+			if unarmored {
+				return clientCtx.Keyring.ImportUnarmoredPrivKey(args[0], string(bz), algo)
+			}
+
 			passphrase, err := input.GetPassword("Enter passphrase to decrypt your key:", buf)
 			if err != nil {
 				return err
@@ -37,4 +46,9 @@ func ImportKeyCommand() *cobra.Command {
 			return clientCtx.Keyring.ImportPrivKey(args[0], string(bz), passphrase)
 		},
 	}
+
+	cmd.Flags().Bool(flagUnarmoredHex, false, "Import unarmored hex privkey")
+	cmd.Flags().String(flagUnarmoredKeyAlgo, string(hd.Secp256k1Type), fmt.Sprintf("defines cryptographic scheme algorithm of the private key (%s, %s, %s, %s)", hd.Secp256k1Type, hd.Ed25519Type, hd.Sr25519Type, hd.MultiType))
+
+	return cmd
 }

crypto/keyring/keyring.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"encoding/hex"
 	"fmt"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	"io"
 	"os"
 	"path/filepath"
@@ -111,6 +112,9 @@ type Importer interface {
 	// ImportPrivKey imports ASCII armored passphrase-encrypted private keys.
 	ImportPrivKey(uid, armor, passphrase string) error
 
+	// ImportUnarmoredPrivKey imports HEX encoded UNARMORED private keys.
+	ImportUnarmoredPrivKey(uid, unarmoredPrivKeyHex, algo string) error
+
 	// ImportPubKey imports ASCII armored public keys.
 	ImportPubKey(uid string, armor string) error
 }
@@ -304,6 +308,43 @@ func (ks keystore) ImportPrivKey(uid, armor, passphrase string) error {
 	return nil
 }
 
+func (ks keystore) ImportUnarmoredPrivKey(uid, unarmoredPrivKeyHex, algo string) error {
+	if _, err := ks.Key(uid); err == nil {
+		return fmt.Errorf("cannot overwrite key: %s", uid)
+	}
+
+	privKeyRaw, err := hex.DecodeString(unarmoredPrivKeyHex)
+	if err != nil {
+		return errors.Wrap(err, "failed to decode provided hex value of private key")
+	}
+
+	var privKey types.PrivKey
+	switch hd.PubKeyType(algo) {
+	case hd.Secp256k1Type:
+		privKey = &secp256k1.PrivKey{Key: privKeyRaw}
+	case hd.Ed25519Type:
+		fallthrough
+	case hd.Sr25519Type:
+		fallthrough
+	case hd.MultiType:
+		fallthrough
+	default:
+		return fmt.Errorf("only the \"%s\" algo is supported at the moment", hd.Secp256k1Type)
+	}
+
+	//privKey, err := legacy.PrivKeyFromBytes(privKeyRaw)
+	//if err != nil {
+	//	return errors.Wrap(err, "failed to create private key from provided hex value")
+	//}
+
+	_, err = ks.writeLocalKey(uid, privKey, hd.PubKeyType(algo))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (ks keystore) ImportPubKey(uid string, armor string) error {
 	if _, err := ks.Key(uid); err == nil {
 		return fmt.Errorf("cannot overwrite key: %s", uid)