status-go/geth/accounts.go

204 lines
6.7 KiB
Go
Raw Normal View History

package geth
import (
2016-06-20 15:21:45 +00:00
"errors"
"fmt"
2016-06-21 18:29:38 +00:00
"github.com/ethereum/go-ethereum/cmd/utils"
"github.com/ethereum/go-ethereum/common"
2016-06-21 14:34:38 +00:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/status-im/status-go/extkeys"
)
var (
ErrAddressToAccountMappingFailure = errors.New("cannot retreive a valid account for a given address")
ErrAccountToKeyMappingFailure = errors.New("cannot retreive a valid key for a given account")
2016-08-23 21:32:04 +00:00
ErrUnlockCalled = errors.New("no need to unlock accounts, login instead")
ErrWhisperIdentityInjectionFailure = errors.New("failed to inject identity into Whisper")
2016-08-29 00:31:16 +00:00
ErrWhisperClearIdentitiesFailure = errors.New("failed to clear whisper identities")
2016-08-23 21:32:04 +00:00
ErrWhisperNoIdentityFound = errors.New("failed to locate identity previously injected into Whisper")
ErrNoAccountSelected = errors.New("no account has been selected, please login")
ErrInvalidMasterKeyCreated = errors.New("can not create master extended key")
)
// createAccount creates an internal geth account
2016-08-23 21:32:04 +00:00
// BIP44-compatible keys are generated: CKD#1 is stored as account key, CKD#2 stored as sub-account root
// Public key of CKD#1 is returned, with CKD#2 securely encoded into account key file (to be used for
// sub-account derivations)
func CreateAccount(password string) (address, pubKey, mnemonic string, err error) {
2016-08-23 21:32:04 +00:00
// generate mnemonic phrase
m := extkeys.NewMnemonic(extkeys.Salt)
2016-08-23 21:32:04 +00:00
mnemonic, err = m.MnemonicPhrase(128, extkeys.EnglishLanguage)
if err != nil {
return "", "", "", fmt.Errorf("can not create mnemonic seed: %v", err)
2016-08-23 21:32:04 +00:00
}
// generate extended master key (see BIP32)
extKey, err := extkeys.NewMaster(m.MnemonicSeed(mnemonic, password), []byte(extkeys.Salt))
if err != nil {
return "", "", "", fmt.Errorf("can not create master extended key: %v", err)
2016-08-23 21:32:04 +00:00
}
// import created key into account keystore
address, pubKey, err = importExtendedKey(extKey, password)
if err != nil {
return "", "", "", err
}
2016-06-29 11:32:04 +00:00
2016-08-23 21:32:04 +00:00
return address, pubKey, mnemonic, nil
}
2016-08-23 21:32:04 +00:00
// createChildAccount creates sub-account for an account identified by parent address.
// CKD#2 is used as root for master accounts (when parentAddress is "").
// Otherwise (when parentAddress != ""), child is derived directly from parent.
func CreateChildAccount(parentAddress, password string) (address, pubKey string, err error) {
nodeManager := GetNodeManager()
accountManager, err := nodeManager.AccountManager()
if err != nil {
return "", "", err
2016-08-23 21:32:04 +00:00
}
if parentAddress == "" { // by default derive from currently selected account
parentAddress = nodeManager.SelectedAddress
2016-08-23 21:32:04 +00:00
}
if parentAddress == "" {
return "", "", ErrNoAccountSelected
}
// make sure that given password can decrypt key associated with a given parent address
account, err := utils.MakeAddress(accountManager, parentAddress)
if err != nil {
return "", "", ErrAddressToAccountMappingFailure
}
account, accountKey, err := accountManager.AccountDecryptedKey(account, password)
if err != nil {
return "", "", fmt.Errorf("%s: %v", ErrAccountToKeyMappingFailure.Error(), err)
}
parentKey, err := extkeys.NewKeyFromString(accountKey.ExtendedKey.String())
if err != nil {
return "", "", err
}
// derive child key
childKey, err := parentKey.Child(accountKey.SubAccountIndex)
if err != nil {
return "", "", err
}
accountManager.IncSubAccountIndex(account, password)
2016-08-23 21:32:04 +00:00
// import derived key into account keystore
address, pubKey, err = importExtendedKey(childKey, password)
if err != nil {
return
}
2016-08-23 21:32:04 +00:00
return address, pubKey, nil
}
2016-08-23 21:32:04 +00:00
// recoverAccount re-creates master key using given details.
// Once master key is re-generated, it is inserted into keystore (if not already there).
func RecoverAccount(password, mnemonic string) (address, pubKey string, err error) {
2016-08-23 21:32:04 +00:00
// re-create extended key (see BIP32)
m := extkeys.NewMnemonic(extkeys.Salt)
2016-08-23 21:32:04 +00:00
extKey, err := extkeys.NewMaster(m.MnemonicSeed(mnemonic, password), []byte(extkeys.Salt))
if err != nil {
return "", "", ErrInvalidMasterKeyCreated
2016-08-23 21:32:04 +00:00
}
2016-08-23 21:32:04 +00:00
// import re-created key into account keystore
address, pubKey, err = importExtendedKey(extKey, password)
if err != nil {
return
}
2016-08-23 21:32:04 +00:00
return address, pubKey, nil
}
2016-06-20 15:21:45 +00:00
2016-08-23 21:32:04 +00:00
// selectAccount selects current account, by verifying that address has corresponding account which can be decrypted
// using provided password. Once verification is done, decrypted key is injected into Whisper (as a single identity,
// all previous identities are removed).
func SelectAccount(address, password string) error {
nodeManager := GetNodeManager()
accountManager, err := nodeManager.AccountManager()
if err != nil {
return err
}
2016-06-21 18:29:38 +00:00
account, err := utils.MakeAddress(accountManager, address)
if err != nil {
return ErrAddressToAccountMappingFailure
}
2016-06-21 18:29:38 +00:00
account, accountKey, err := accountManager.AccountDecryptedKey(account, password)
if err != nil {
return fmt.Errorf("%s: %v", ErrAccountToKeyMappingFailure.Error(), err)
}
whisperService, err := nodeManager.WhisperService()
if err != nil {
return err
2016-06-21 18:29:38 +00:00
}
if err := whisperService.InjectIdentity(accountKey.PrivateKey); err != nil {
return ErrWhisperIdentityInjectionFailure
}
2016-08-23 21:32:04 +00:00
// persist address for easier recovery of currently selected key (from Whisper)
nodeManager.SelectedAddress = address
2016-08-23 21:32:04 +00:00
return nil
}
2016-06-21 18:29:38 +00:00
2016-08-29 00:31:16 +00:00
// logout clears whisper identities
func Logout() error {
nodeManager := GetNodeManager()
whisperService, err := nodeManager.WhisperService()
if err != nil {
return err
2016-08-29 00:31:16 +00:00
}
err = whisperService.ClearIdentities()
2016-08-29 00:31:16 +00:00
if err != nil {
return fmt.Errorf("%s: %v", ErrWhisperClearIdentitiesFailure, err)
}
nodeManager.SelectedAddress = ""
2016-08-23 21:32:04 +00:00
2016-08-29 00:31:16 +00:00
return nil
}
// unlockAccount unlocks an existing account for a certain duration and
// inject the account as a whisper identity if the account was created as
// a whisper enabled account
func UnlockAccount(address, password string, seconds int) error {
return ErrUnlockCalled
2016-06-21 18:29:38 +00:00
}
2016-08-23 21:32:04 +00:00
// importExtendedKey processes incoming extended key, extracts required info and creates corresponding account key.
// Once account key is formed, that key is put (if not already) into keystore i.e. key is *encoded* into key file.
func importExtendedKey(extKey *extkeys.ExtendedKey, password string) (address, pubKey string, err error) {
accountManager, err := GetNodeManager().AccountManager()
if err != nil {
return "", "", err
}
2016-08-23 21:32:04 +00:00
// imports extended key, create key file (if necessary)
account, err := accountManager.ImportExtendedKey(extKey, password)
if err != nil {
return "", "", err
2016-08-23 21:32:04 +00:00
}
address = fmt.Sprintf("%x", account.Address)
// obtain public key to return
account, key, err := accountManager.AccountDecryptedKey(account, password)
if err != nil {
return address, "", err
2016-08-23 21:32:04 +00:00
}
pubKey = common.ToHex(crypto.FromECDSAPub(&key.PrivateKey.PublicKey))
return
}