From 5304f43067c24e24eb8b8550c0db67fdbcc94718 Mon Sep 17 00:00:00 2001 From: Bas van Kervel Date: Wed, 8 Apr 2015 15:43:55 +0200 Subject: [PATCH 1/4] Add path expansion support for command line arguments, closes 567 --- cmd/utils/customflags.go | 133 ++++++++++++++++++++++++++++++++++ cmd/utils/customflags_test.go | 28 +++++++ cmd/utils/flags.go | 6 +- 3 files changed, 164 insertions(+), 3 deletions(-) create mode 100644 cmd/utils/customflags.go create mode 100644 cmd/utils/customflags_test.go diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go new file mode 100644 index 000000000..6d4a87bfb --- /dev/null +++ b/cmd/utils/customflags.go @@ -0,0 +1,133 @@ +package utils +import ( + "path/filepath" + "os" + "strings" + "os/user" + "github.com/codegangsta/cli" + "flag" + "fmt" +) + +// Custom type which is registered in the flags library which cli uses for +// argument parsing. This allows us to expand Value to an absolute path when +// the argument is parsed +type DirectoryString struct { + Value string +} + +func (self DirectoryString) String() string { + return self.Value +} + +func (self DirectoryString) Set(value string) error { + self.Value = expandPath(value) + return nil +} + +// Custom cli.Flag type which expand the received string to an absolute path. +// e.g. ~/.ethereum -> /home/username/.ethereum +type DirectoryFlag struct { + cli.GenericFlag + Name string + Value DirectoryString + Usage string + EnvVar string +} + +func (self DirectoryFlag) String() string { + var fmtString string + fmtString = "%s %v\t%v" + + if len(self.Value.Value) > 0 { + fmtString = "%s \"%v\"\t%v" + } else { + fmtString = "%s %v\t%v" + } + + return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage)) +} + +func eachName(longName string, fn func(string)) { + parts := strings.Split(longName, ",") + for _, name := range parts { + name = strings.Trim(name, " ") + fn(name) + } +} +// called by cli library, grabs variable from environment (if in env) +// and adds variable to flag set for parsing. +func (self DirectoryFlag) Apply(set *flag.FlagSet) { + if self.EnvVar != "" { + for _, envVar := range strings.Split(self.EnvVar, ",") { + envVar = strings.TrimSpace(envVar) + if envVal := os.Getenv(envVar); envVal != "" { + self.Value.Value = envVal + break + } + } + } + + eachName(self.Name, func(name string) { + set.Var(self.Value, self.Name, "a: " + self.Usage) + }) + +} + +func prefixFor(name string) (prefix string) { + if len(name) == 1 { + prefix = "-" + } else { + prefix = "--" + } + + return +} + +func prefixedNames(fullName string) (prefixed string) { + parts := strings.Split(fullName, ",") + for i, name := range parts { + name = strings.Trim(name, " ") + prefixed += prefixFor(name) + name + if i < len(parts)-1 { + prefixed += ", " + } + } + return +} + +func withEnvHint(envVar, str string) string { + envText := "" + if envVar != "" { + envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $")) + } + return str + envText +} + +func (self DirectoryFlag) getName() string { + return self.Name +} + +func (self *DirectoryFlag) Set(value string) { + self.Value.Value = value +} + +// Expands a file path +// 1. replace tilde with users home dir +// 2. expands embedded environment variables +// 3. cleans the path, e.g. /a/b/../c -> /a/c +// Note, it has limitations, e.g. ~someuser/tmp will not be expanded +func expandPath(p string) string { + if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") { + if user, err := user.Current(); err == nil { + if err == nil { + p = strings.Replace(p, "~", user.HomeDir, 1) + } + } + } + + return filepath.Clean(os.ExpandEnv(p)) +} + + + diff --git a/cmd/utils/customflags_test.go b/cmd/utils/customflags_test.go new file mode 100644 index 000000000..5674b939e --- /dev/null +++ b/cmd/utils/customflags_test.go @@ -0,0 +1,28 @@ +package utils + +import ( + "testing" + "os" + "os/user" +) + +func TestPathExpansion(t *testing.T) { + + user, _ := user.Current() + + tests := map[string]string { + "/home/someuser/tmp": "/home/someuser/tmp", + "~/tmp": user.HomeDir + "/tmp", + "$DDDXXX/a/b": "/tmp/a/b", + "/a/b/": "/a/b", + } + + os.Setenv("DDDXXX", "/tmp") + + for test, expected := range tests { + got := expandPath(test) + if got != expected { + t.Errorf("test %s, got %s, expected %s\n", test, got, expected) + } + } +} diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 51844a68e..461d34ebc 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -68,10 +68,10 @@ func NewApp(version, usage string) *cli.App { var ( // General settings - DataDirFlag = cli.StringFlag{ - Name: "datadir", + DataDirFlag = DirectoryFlag{ + Name: "datadir", Usage: "Data directory to be used", - Value: common.DefaultDataDir(), + Value: DirectoryString{common.DefaultDataDir()}, } ProtocolVersionFlag = cli.IntFlag{ Name: "protocolversion", From b3a3fdf9a447bd2b3f862380d87c675138da78e7 Mon Sep 17 00:00:00 2001 From: Bas van Kervel Date: Wed, 8 Apr 2015 23:03:47 +0200 Subject: [PATCH 2/4] Support for import/export hex encoded keys, closes #635 --- cmd/geth/main.go | 3 +-- common/bytes.go | 12 ++++++++++++ crypto/crypto.go | 6 +++--- 3 files changed, 16 insertions(+), 5 deletions(-) diff --git a/cmd/geth/main.go b/cmd/geth/main.go index 9437f8eb4..02964dadf 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -149,8 +149,7 @@ password to file or expose in any other way. Imports an unencrypted private key from and creates a new account. Prints the address. -The keyfile is assumed to contain an unencrypted private key in canonical EC -raw bytes format. +The keyfile is assumed to contain an unencrypted private key in hexadecimal format. The account is saved in encrypted format, you are prompted for a passphrase. diff --git a/common/bytes.go b/common/bytes.go index 5bdacd810..ba180ac94 100644 --- a/common/bytes.go +++ b/common/bytes.go @@ -147,6 +147,18 @@ func Hex2Bytes(str string) []byte { return h } +func HexBytes2Bytes(d []byte) []byte { + r := make([]byte, hex.DecodedLen(len(d))) + hex.Decode(r, d) + return r +} + +func Bytes2HexBytes(d []byte) []byte { + r := make([]byte, hex.EncodedLen(len(d))) + hex.Encode(r, d) + return r +} + func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) { if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") { ret = Hex2Bytes(str[2:]) diff --git a/crypto/crypto.go b/crypto/crypto.go index 7d1d51fa6..6e3ffbd4a 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -121,7 +121,7 @@ func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error) { // LoadECDSA loads a secp256k1 private key from the given file. func LoadECDSA(file string) (*ecdsa.PrivateKey, error) { - buf := make([]byte, 32) + buf := make([]byte, 64) fd, err := os.Open(file) if err != nil { return nil, err @@ -130,13 +130,13 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) { if _, err := io.ReadFull(fd, buf); err != nil { return nil, err } - return ToECDSA(buf), nil + return ToECDSA(common.HexBytes2Bytes(buf)), nil } // SaveECDSA saves a secp256k1 private key to the given file with restrictive // permissions func SaveECDSA(file string, key *ecdsa.PrivateKey) error { - return ioutil.WriteFile(file, FromECDSA(key), 0600) + return ioutil.WriteFile(file, common.Bytes2HexBytes(FromECDSA(key)), 0600) } func GenerateKey() (*ecdsa.PrivateKey, error) { From 6da5b2fc5fc0fe703158411afcd4f05add0336f2 Mon Sep 17 00:00:00 2001 From: Bas van Kervel Date: Thu, 9 Apr 2015 10:26:26 +0200 Subject: [PATCH 3/4] reformat code with goimports --- cmd/utils/customflags.go | 148 +++++++++++++++++----------------- cmd/utils/customflags_test.go | 34 ++++---- cmd/utils/flags.go | 2 +- 3 files changed, 92 insertions(+), 92 deletions(-) diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go index 6d4a87bfb..a623ae19c 100644 --- a/cmd/utils/customflags.go +++ b/cmd/utils/customflags.go @@ -1,115 +1,118 @@ package utils + import ( - "path/filepath" - "os" - "strings" - "os/user" - "github.com/codegangsta/cli" - "flag" - "fmt" + "flag" + "fmt" + "os" + "os/user" + "path/filepath" + "strings" + + "github.com/codegangsta/cli" ) // Custom type which is registered in the flags library which cli uses for // argument parsing. This allows us to expand Value to an absolute path when // the argument is parsed type DirectoryString struct { - Value string + Value string } func (self DirectoryString) String() string { - return self.Value + return self.Value } func (self DirectoryString) Set(value string) error { - self.Value = expandPath(value) - return nil + self.Value = expandPath(value) + return nil } // Custom cli.Flag type which expand the received string to an absolute path. // e.g. ~/.ethereum -> /home/username/.ethereum type DirectoryFlag struct { - cli.GenericFlag - Name string - Value DirectoryString - Usage string - EnvVar string + cli.GenericFlag + Name string + Value DirectoryString + Usage string + EnvVar string } func (self DirectoryFlag) String() string { - var fmtString string - fmtString = "%s %v\t%v" + var fmtString string + fmtString = "%s %v\t%v" - if len(self.Value.Value) > 0 { - fmtString = "%s \"%v\"\t%v" - } else { - fmtString = "%s %v\t%v" - } + if len(self.Value.Value) > 0 { + fmtString = "%s \"%v\"\t%v" + } else { + fmtString = "%s %v\t%v" + } - return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage)) + return withEnvHint(self.EnvVar, fmt.Sprintf(fmtString, prefixedNames(self.Name), self.Value.Value, self.Usage)) } func eachName(longName string, fn func(string)) { - parts := strings.Split(longName, ",") - for _, name := range parts { - name = strings.Trim(name, " ") - fn(name) - } + parts := strings.Split(longName, ",") + for _, name := range parts { + name = strings.Trim(name, " ") + fn(name) + } } + // called by cli library, grabs variable from environment (if in env) // and adds variable to flag set for parsing. func (self DirectoryFlag) Apply(set *flag.FlagSet) { - if self.EnvVar != "" { - for _, envVar := range strings.Split(self.EnvVar, ",") { - envVar = strings.TrimSpace(envVar) - if envVal := os.Getenv(envVar); envVal != "" { - self.Value.Value = envVal - break - } - } - } + if self.EnvVar != "" { + for _, envVar := range strings.Split(self.EnvVar, ",") { + envVar = strings.TrimSpace(envVar) + if envVal := os.Getenv(envVar); envVal != "" { + self.Value.Value = envVal + break + } + } + } - eachName(self.Name, func(name string) { - set.Var(self.Value, self.Name, "a: " + self.Usage) - }) + eachName(self.Name, func(name string) { + set.Var(self.Value, self.Name, "a: "+self.Usage) + }) } func prefixFor(name string) (prefix string) { - if len(name) == 1 { - prefix = "-" - } else { - prefix = "--" - } + if len(name) == 1 { + prefix = "-" + } else { + prefix = "--" + } - return + return } func prefixedNames(fullName string) (prefixed string) { - parts := strings.Split(fullName, ",") - for i, name := range parts { - name = strings.Trim(name, " ") - prefixed += prefixFor(name) + name - if i < len(parts)-1 { - prefixed += ", " - } - } - return + parts := strings.Split(fullName, ",") + for i, name := range parts { + name = strings.Trim(name, " ") + prefixed += prefixFor(name) + name + if i < len(parts)-1 { + prefixed += ", " + } + } + return } func withEnvHint(envVar, str string) string { - envText := "" - if envVar != "" { - envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $")) - } - return str + envText + envText := "" + if envVar != "" { + envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $")) + } + return str + envText } func (self DirectoryFlag) getName() string { - return self.Name + return self.Name } func (self *DirectoryFlag) Set(value string) { - self.Value.Value = value + self.Value.Value = value } // Expands a file path @@ -118,16 +121,13 @@ func (self *DirectoryFlag) Set(value string) { // 3. cleans the path, e.g. /a/b/../c -> /a/c // Note, it has limitations, e.g. ~someuser/tmp will not be expanded func expandPath(p string) string { - if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") { - if user, err := user.Current(); err == nil { - if err == nil { - p = strings.Replace(p, "~", user.HomeDir, 1) - } - } - } + if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") { + if user, err := user.Current(); err == nil { + if err == nil { + p = strings.Replace(p, "~", user.HomeDir, 1) + } + } + } - return filepath.Clean(os.ExpandEnv(p)) + return filepath.Clean(os.ExpandEnv(p)) } - - - diff --git a/cmd/utils/customflags_test.go b/cmd/utils/customflags_test.go index 5674b939e..11deb38ef 100644 --- a/cmd/utils/customflags_test.go +++ b/cmd/utils/customflags_test.go @@ -1,28 +1,28 @@ package utils import ( - "testing" - "os" - "os/user" + "os" + "os/user" + "testing" ) func TestPathExpansion(t *testing.T) { - user, _ := user.Current() + user, _ := user.Current() - tests := map[string]string { - "/home/someuser/tmp": "/home/someuser/tmp", - "~/tmp": user.HomeDir + "/tmp", - "$DDDXXX/a/b": "/tmp/a/b", - "/a/b/": "/a/b", - } + tests := map[string]string{ + "/home/someuser/tmp": "/home/someuser/tmp", + "~/tmp": user.HomeDir + "/tmp", + "$DDDXXX/a/b": "/tmp/a/b", + "/a/b/": "/a/b", + } - os.Setenv("DDDXXX", "/tmp") + os.Setenv("DDDXXX", "/tmp") - for test, expected := range tests { - got := expandPath(test) - if got != expected { - t.Errorf("test %s, got %s, expected %s\n", test, got, expected) - } - } + for test, expected := range tests { + got := expandPath(test) + if got != expected { + t.Errorf("test %s, got %s, expected %s\n", test, got, expected) + } + } } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 461d34ebc..bfd1ab990 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -69,7 +69,7 @@ func NewApp(version, usage string) *cli.App { var ( // General settings DataDirFlag = DirectoryFlag{ - Name: "datadir", + Name: "datadir", Usage: "Data directory to be used", Value: DirectoryString{common.DefaultDataDir()}, } From ef393da9334adcf99187c0825df025596ae41fb3 Mon Sep 17 00:00:00 2001 From: Bas van Kervel Date: Thu, 9 Apr 2015 10:59:37 +0200 Subject: [PATCH 4/4] removed utility function and implemented hex conversation in crypto functions --- common/bytes.go | 12 ------------ crypto/crypto.go | 11 +++++++++-- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/common/bytes.go b/common/bytes.go index ba180ac94..5bdacd810 100644 --- a/common/bytes.go +++ b/common/bytes.go @@ -147,18 +147,6 @@ func Hex2Bytes(str string) []byte { return h } -func HexBytes2Bytes(d []byte) []byte { - r := make([]byte, hex.DecodedLen(len(d))) - hex.Decode(r, d) - return r -} - -func Bytes2HexBytes(d []byte) []byte { - r := make([]byte, hex.EncodedLen(len(d))) - hex.Encode(r, d) - return r -} - func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) { if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") { ret = Hex2Bytes(str[2:]) diff --git a/crypto/crypto.go b/crypto/crypto.go index 6e3ffbd4a..9865c87c4 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -130,13 +130,20 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) { if _, err := io.ReadFull(fd, buf); err != nil { return nil, err } - return ToECDSA(common.HexBytes2Bytes(buf)), nil + + key, err := hex.DecodeString(string(buf)) + if err != nil { + return nil, err + } + + return ToECDSA(key), nil } // SaveECDSA saves a secp256k1 private key to the given file with restrictive // permissions func SaveECDSA(file string, key *ecdsa.PrivateKey) error { - return ioutil.WriteFile(file, common.Bytes2HexBytes(FromECDSA(key)), 0600) + k := hex.EncodeToString(FromECDSA(key)) + return ioutil.WriteFile(file, []byte(k), 0600) } func GenerateKey() (*ecdsa.PrivateKey, error) {