From cda91ee18006ee0d012d905385c30485eab8be12 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Tue, 16 Feb 2016 23:28:11 +0200 Subject: [PATCH 1/3] crypto: expose key decryption method to parse a string direclty --- crypto/key_store_passphrase.go | 63 ++++++++++++++++++++-------------- crypto/key_store_plain.go | 18 +++++----- 2 files changed, 45 insertions(+), 36 deletions(-) diff --git a/crypto/key_store_passphrase.go b/crypto/key_store_passphrase.go index b7ae9e1de..1e8d5509b 100644 --- a/crypto/key_store_passphrase.go +++ b/crypto/key_store_passphrase.go @@ -75,15 +75,7 @@ func (ks keyStorePassphrase) GenerateNewKey(rand io.Reader, auth string) (key *K } func (ks keyStorePassphrase) GetKey(keyAddr common.Address, auth string) (key *Key, err error) { - keyBytes, keyId, err := decryptKeyFromFile(ks.keysDirPath, keyAddr, auth) - if err == nil { - key = &Key{ - Id: uuid.UUID(keyId), - Address: keyAddr, - PrivateKey: ToECDSA(keyBytes), - } - } - return + return decryptKeyFromFile(ks.keysDirPath, keyAddr, auth) } func (ks keyStorePassphrase) Cleanup(keyAddr common.Address) (err error) { @@ -145,39 +137,58 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) { return writeKeyFile(key.Address, ks.keysDirPath, keyJSON) } -func (ks keyStorePassphrase) DeleteKey(keyAddr common.Address, auth string) (err error) { +func (ks keyStorePassphrase) DeleteKey(keyAddr common.Address, auth string) error { // only delete if correct passphrase is given - _, _, err = decryptKeyFromFile(ks.keysDirPath, keyAddr, auth) - if err != nil { + if _, err := decryptKeyFromFile(ks.keysDirPath, keyAddr, auth); err != nil { return err } - return deleteKey(ks.keysDirPath, keyAddr) } -func decryptKeyFromFile(keysDirPath string, keyAddr common.Address, auth string) (keyBytes []byte, keyId []byte, err error) { +// DecryptKey decrypts a key from a json blob, returning the private key itself. +func DecryptKey(keyjson []byte, auth string) (*Key, error) { + // Parse the json into a simple map to fetch the key version m := make(map[string]interface{}) - err = getKey(keysDirPath, keyAddr, &m) - if err != nil { - return + if err := json.Unmarshal(keyjson, &m); err != nil { + return nil, err } - + // Depending on the version try to parse one way or another + var ( + keyBytes, keyId []byte + err error + ) v := reflect.ValueOf(m["version"]) if v.Kind() == reflect.String && v.String() == "1" { k := new(encryptedKeyJSONV1) - err = getKey(keysDirPath, keyAddr, &k) - if err != nil { - return + if err := json.Unmarshal(keyjson, k); err != nil { + return nil, err } - return decryptKeyV1(k, auth) + keyBytes, keyId, err = decryptKeyV1(k, auth) } else { k := new(encryptedKeyJSONV3) - err = getKey(keysDirPath, keyAddr, &k) - if err != nil { - return + if err := json.Unmarshal(keyjson, k); err != nil { + return nil, err } - return decryptKeyV3(k, auth) + keyBytes, keyId, err = decryptKeyV3(k, auth) } + // Handle any decryption errors and return the key + if err != nil { + return nil, err + } + key := ToECDSA(keyBytes) + return &Key{ + Id: uuid.UUID(keyId), + Address: PubkeyToAddress(key.PublicKey), + PrivateKey: key, + }, nil +} + +func decryptKeyFromFile(keysDirPath string, keyAddr common.Address, auth string) (key *Key, err error) { + keyjson, err := getKeyFile(keysDirPath, keyAddr) + if err != nil { + return nil, err + } + return DecryptKey(keyjson, auth) } func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byte, keyId []byte, err error) { diff --git a/crypto/key_store_plain.go b/crypto/key_store_plain.go index c1c23f8b8..4ce789a30 100644 --- a/crypto/key_store_plain.go +++ b/crypto/key_store_plain.go @@ -62,18 +62,16 @@ func GenerateNewKeyDefault(ks KeyStore, rand io.Reader, auth string) (key *Key, return key, err } -func (ks keyStorePlain) GetKey(keyAddr common.Address, auth string) (key *Key, err error) { - key = new(Key) - err = getKey(ks.keysDirPath, keyAddr, key) - return -} - -func getKey(keysDirPath string, keyAddr common.Address, content interface{}) (err error) { - fileContent, err := getKeyFile(keysDirPath, keyAddr) +func (ks keyStorePlain) GetKey(keyAddr common.Address, auth string) (*Key, error) { + keyjson, err := getKeyFile(ks.keysDirPath, keyAddr) if err != nil { - return + return nil, err } - return json.Unmarshal(fileContent, content) + key := new(Key) + if err := json.Unmarshal(keyjson, key); err != nil { + return nil, err + } + return key, nil } func (ks keyStorePlain) GetKeyAddresses() (addresses []common.Address, err error) { From 0969b35eec7b1e4a514b9fb3d659706d9f09ee2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 17 Feb 2016 00:38:34 +0200 Subject: [PATCH 2/3] crypto: code polish + ensure key file contents match with name --- crypto/key_store_passphrase.go | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/crypto/key_store_passphrase.go b/crypto/key_store_passphrase.go index 1e8d5509b..2700b0f1c 100644 --- a/crypto/key_store_passphrase.go +++ b/crypto/key_store_passphrase.go @@ -34,7 +34,6 @@ import ( "errors" "fmt" "io" - "reflect" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto/randentropy" @@ -157,8 +156,7 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) { keyBytes, keyId []byte err error ) - v := reflect.ValueOf(m["version"]) - if v.Kind() == reflect.String && v.String() == "1" { + if version, ok := m["version"].(string); ok && version == "1" { k := new(encryptedKeyJSONV1) if err := json.Unmarshal(keyjson, k); err != nil { return nil, err @@ -183,12 +181,21 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) { }, nil } -func decryptKeyFromFile(keysDirPath string, keyAddr common.Address, auth string) (key *Key, err error) { +func decryptKeyFromFile(keysDirPath string, keyAddr common.Address, auth string) (*Key, error) { + // Load the key from the keystore and decrypt its contents keyjson, err := getKeyFile(keysDirPath, keyAddr) if err != nil { return nil, err } - return DecryptKey(keyjson, auth) + key, err := DecryptKey(keyjson, auth) + if err != nil { + return nil, err + } + // Make sure we're really operating on the requested key (no swap attacks) + if keyAddr != key.Address { + return nil, fmt.Errorf("key content mismatch: have account %x, want %x", key.Address, keyAddr) + } + return key, nil } func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byte, keyId []byte, err error) { From 45d08a8aa7fdc3aecdcf524f0c19946b1e068e1a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 17 Feb 2016 01:15:35 +0200 Subject: [PATCH 3/3] crypto: expose key encryption method, add ping-pong test --- crypto/key_store_passphrase.go | 40 +++++++++++----------- crypto/key_store_passphrase_test.go | 51 +++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 19 deletions(-) create mode 100644 crypto/key_store_passphrase_test.go diff --git a/crypto/key_store_passphrase.go b/crypto/key_store_passphrase.go index 2700b0f1c..19e77de91 100644 --- a/crypto/key_store_passphrase.go +++ b/crypto/key_store_passphrase.go @@ -61,12 +61,10 @@ type keyStorePassphrase struct { keysDirPath string scryptN int scryptP int - scryptR int - scryptDKLen int } func NewKeyStorePassphrase(path string, scryptN int, scryptP int) KeyStore { - return &keyStorePassphrase{path, scryptN, scryptP, scryptR, scryptDKLen} + return &keyStorePassphrase{path, scryptN, scryptP} } func (ks keyStorePassphrase) GenerateNewKey(rand io.Reader, auth string) (key *Key, err error) { @@ -85,29 +83,38 @@ func (ks keyStorePassphrase) GetKeyAddresses() (addresses []common.Address, err return getKeyAddresses(ks.keysDirPath) } -func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) { - authArray := []byte(auth) - salt := randentropy.GetEntropyCSPRNG(32) - derivedKey, err := scrypt.Key(authArray, salt, ks.scryptN, ks.scryptR, ks.scryptP, ks.scryptDKLen) +func (ks keyStorePassphrase) StoreKey(key *Key, auth string) error { + keyjson, err := EncryptKey(key, auth, ks.scryptN, ks.scryptP) if err != nil { return err } + return writeKeyFile(key.Address, ks.keysDirPath, keyjson) +} + +// EncryptKey encrypts a key using the specified scrypt parameters into a json +// blob that can be decrypted later on. +func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error) { + authArray := []byte(auth) + salt := randentropy.GetEntropyCSPRNG(32) + derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptR, scryptP, scryptDKLen) + if err != nil { + return nil, err + } encryptKey := derivedKey[:16] keyBytes := FromECDSA(key.PrivateKey) iv := randentropy.GetEntropyCSPRNG(aes.BlockSize) // 16 cipherText, err := aesCTRXOR(encryptKey, keyBytes, iv) if err != nil { - return err + return nil, err } - mac := Keccak256(derivedKey[16:32], cipherText) scryptParamsJSON := make(map[string]interface{}, 5) - scryptParamsJSON["n"] = ks.scryptN - scryptParamsJSON["r"] = ks.scryptR - scryptParamsJSON["p"] = ks.scryptP - scryptParamsJSON["dklen"] = ks.scryptDKLen + scryptParamsJSON["n"] = scryptN + scryptParamsJSON["r"] = scryptR + scryptParamsJSON["p"] = scryptP + scryptParamsJSON["dklen"] = scryptDKLen scryptParamsJSON["salt"] = hex.EncodeToString(salt) cipherParamsJSON := cipherparamsJSON{ @@ -128,12 +135,7 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) { key.Id.String(), version, } - keyJSON, err := json.Marshal(encryptedKeyJSONV3) - if err != nil { - return err - } - - return writeKeyFile(key.Address, ks.keysDirPath, keyJSON) + return json.Marshal(encryptedKeyJSONV3) } func (ks keyStorePassphrase) DeleteKey(keyAddr common.Address, auth string) error { diff --git a/crypto/key_store_passphrase_test.go b/crypto/key_store_passphrase_test.go new file mode 100644 index 000000000..bcdd58ad9 --- /dev/null +++ b/crypto/key_store_passphrase_test.go @@ -0,0 +1,51 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package crypto + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" +) + +// Tests that a json key file can be decrypted and encrypted in multiple rounds. +func TestKeyEncryptDecrypt(t *testing.T) { + address := common.HexToAddress("f626acac23772cbe04dd578bee681b06bdefb9fa") + keyjson := []byte("{\"address\":\"f626acac23772cbe04dd578bee681b06bdefb9fa\",\"crypto\":{\"cipher\":\"aes-128-ctr\",\"ciphertext\":\"1bcf0ab9b14459795ce59f63e63255ffd84dc38d31614a5a78e37144d7e4a17f\",\"cipherparams\":{\"iv\":\"df4c7e225ee2d81adef522013e3fbe24\"},\"kdf\":\"scrypt\",\"kdfparams\":{\"dklen\":32,\"n\":262144,\"p\":1,\"r\":8,\"salt\":\"2909a99dd2bfa7079a4b40991773b1083f8512c0c55b9b63402ab0e3dc8db8b3\"},\"mac\":\"4ecf6a4ad92ae2c016cb7c44abade74799480c3303eb024661270dfefdbc7510\"},\"id\":\"b4718210-9a30-4883-b8a6-dbdd08bd0ceb\",\"version\":3}") + password := "" + + // Do a few rounds of decryption and encryption + for i := 0; i < 3; i++ { + // Try a bad password first + if _, err := DecryptKey(keyjson, password+"bad"); err == nil { + t.Error("test %d: json key decrypted with bad password", i) + } + // Decrypt with the correct password + key, err := DecryptKey(keyjson, password) + if err != nil { + t.Errorf("test %d: json key failed to decrypt: %v", i, err) + } + if key.Address != address { + t.Errorf("test %d: key address mismatch: have %x, want %x", i, key.Address, address) + } + // Recrypt with a new password and start over + password += "new data appended" + if keyjson, err = EncryptKey(key, password, LightScryptN, LightScryptP); err != nil { + t.Errorf("test %d: failed to recrypt key %v", err) + } + } +}