github.com/ylsGit/go-ethereum@v1.6.5/accounts/keystore/key.go (about) 1 // Copyright 2014 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package keystore 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "encoding/hex" 23 "encoding/json" 24 "fmt" 25 "io" 26 "io/ioutil" 27 "os" 28 "path/filepath" 29 "strings" 30 "time" 31 32 "github.com/ethereum/go-ethereum/accounts" 33 "github.com/ethereum/go-ethereum/common" 34 "github.com/ethereum/go-ethereum/crypto" 35 "github.com/pborman/uuid" 36 ) 37 38 const ( 39 version = 3 40 ) 41 42 type Key struct { 43 Id uuid.UUID // Version 4 "random" for unique id not derived from key data 44 // to simplify lookups we also store the address 45 Address common.Address 46 // we only store privkey as pubkey/address can be derived from it 47 // privkey in this struct is always in plaintext 48 PrivateKey *ecdsa.PrivateKey 49 } 50 51 type keyStore interface { 52 // Loads and decrypts the key from disk. 53 GetKey(addr common.Address, filename string, auth string) (*Key, error) 54 // Writes and encrypts the key. 55 StoreKey(filename string, k *Key, auth string) error 56 // Joins filename with the key directory unless it is already absolute. 57 JoinPath(filename string) string 58 } 59 60 type plainKeyJSON struct { 61 Address string `json:"address"` 62 PrivateKey string `json:"privatekey"` 63 Id string `json:"id"` 64 Version int `json:"version"` 65 } 66 67 type encryptedKeyJSONV3 struct { 68 Address string `json:"address"` 69 Crypto cryptoJSON `json:"crypto"` 70 Id string `json:"id"` 71 Version int `json:"version"` 72 } 73 74 type encryptedKeyJSONV1 struct { 75 Address string `json:"address"` 76 Crypto cryptoJSON `json:"crypto"` 77 Id string `json:"id"` 78 Version string `json:"version"` 79 } 80 81 type cryptoJSON struct { 82 Cipher string `json:"cipher"` 83 CipherText string `json:"ciphertext"` 84 CipherParams cipherparamsJSON `json:"cipherparams"` 85 KDF string `json:"kdf"` 86 KDFParams map[string]interface{} `json:"kdfparams"` 87 MAC string `json:"mac"` 88 } 89 90 type cipherparamsJSON struct { 91 IV string `json:"iv"` 92 } 93 94 type scryptParamsJSON struct { 95 N int `json:"n"` 96 R int `json:"r"` 97 P int `json:"p"` 98 DkLen int `json:"dklen"` 99 Salt string `json:"salt"` 100 } 101 102 func (k *Key) MarshalJSON() (j []byte, err error) { 103 jStruct := plainKeyJSON{ 104 hex.EncodeToString(k.Address[:]), 105 hex.EncodeToString(crypto.FromECDSA(k.PrivateKey)), 106 k.Id.String(), 107 version, 108 } 109 j, err = json.Marshal(jStruct) 110 return j, err 111 } 112 113 func (k *Key) UnmarshalJSON(j []byte) (err error) { 114 keyJSON := new(plainKeyJSON) 115 err = json.Unmarshal(j, &keyJSON) 116 if err != nil { 117 return err 118 } 119 120 u := new(uuid.UUID) 121 *u = uuid.Parse(keyJSON.Id) 122 k.Id = *u 123 addr, err := hex.DecodeString(keyJSON.Address) 124 if err != nil { 125 return err 126 } 127 privkey, err := crypto.HexToECDSA(keyJSON.PrivateKey) 128 if err != nil { 129 return err 130 } 131 132 k.Address = common.BytesToAddress(addr) 133 k.PrivateKey = privkey 134 135 return nil 136 } 137 138 func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key { 139 id := uuid.NewRandom() 140 key := &Key{ 141 Id: id, 142 Address: crypto.PubkeyToAddress(privateKeyECDSA.PublicKey), 143 PrivateKey: privateKeyECDSA, 144 } 145 return key 146 } 147 148 // NewKeyForDirectICAP generates a key whose address fits into < 155 bits so it can fit 149 // into the Direct ICAP spec. for simplicity and easier compatibility with other libs, we 150 // retry until the first byte is 0. 151 func NewKeyForDirectICAP(rand io.Reader) *Key { 152 randBytes := make([]byte, 64) 153 _, err := rand.Read(randBytes) 154 if err != nil { 155 panic("key generation: could not read from random source: " + err.Error()) 156 } 157 reader := bytes.NewReader(randBytes) 158 privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), reader) 159 if err != nil { 160 panic("key generation: ecdsa.GenerateKey failed: " + err.Error()) 161 } 162 key := newKeyFromECDSA(privateKeyECDSA) 163 if !strings.HasPrefix(key.Address.Hex(), "0x00") { 164 return NewKeyForDirectICAP(rand) 165 } 166 return key 167 } 168 169 func newKey(rand io.Reader) (*Key, error) { 170 privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), rand) 171 if err != nil { 172 return nil, err 173 } 174 return newKeyFromECDSA(privateKeyECDSA), nil 175 } 176 177 func storeNewKey(ks keyStore, rand io.Reader, auth string) (*Key, accounts.Account, error) { 178 key, err := newKey(rand) 179 if err != nil { 180 return nil, accounts.Account{}, err 181 } 182 a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.JoinPath(keyFileName(key.Address))}} 183 if err := ks.StoreKey(a.URL.Path, key, auth); err != nil { 184 zeroKey(key.PrivateKey) 185 return nil, a, err 186 } 187 return key, a, err 188 } 189 190 func writeKeyFile(file string, content []byte) error { 191 // Create the keystore directory with appropriate permissions 192 // in case it is not present yet. 193 const dirPerm = 0700 194 if err := os.MkdirAll(filepath.Dir(file), dirPerm); err != nil { 195 return err 196 } 197 // Atomic write: create a temporary hidden file first 198 // then move it into place. TempFile assigns mode 0600. 199 f, err := ioutil.TempFile(filepath.Dir(file), "."+filepath.Base(file)+".tmp") 200 if err != nil { 201 return err 202 } 203 if _, err := f.Write(content); err != nil { 204 f.Close() 205 os.Remove(f.Name()) 206 return err 207 } 208 f.Close() 209 return os.Rename(f.Name(), file) 210 } 211 212 // keyFileName implements the naming convention for keyfiles: 213 // UTC--<created_at UTC ISO8601>-<address hex> 214 func keyFileName(keyAddr common.Address) string { 215 ts := time.Now().UTC() 216 return fmt.Sprintf("UTC--%s--%s", toISO8601(ts), hex.EncodeToString(keyAddr[:])) 217 } 218 219 func toISO8601(t time.Time) string { 220 var tz string 221 name, offset := t.Zone() 222 if name == "UTC" { 223 tz = "Z" 224 } else { 225 tz = fmt.Sprintf("%03d00", offset/3600) 226 } 227 return fmt.Sprintf("%04d-%02d-%02dT%02d-%02d-%02d.%09d%s", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), tz) 228 }