aboutsummaryrefslogtreecommitdiffstats
path: root/accounts/keystore/keystore.go
blob: 80ccd37419f91b8dac4310a2cd4bcf29a13ef229 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
// Copyright 2017 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 <http://www.gnu.org/licenses/>.

// Package keystore implements encrypted storage of secp256k1 private keys.
//
// Keys are stored as encrypted JSON files according to the Web3 Secret Storage specification.
// See https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition for more information.
package keystore

import (
    "crypto/ecdsa"
    crand "crypto/rand"
    "errors"
    "fmt"
    "math/big"
    "os"
    "path/filepath"
    "reflect"
    "runtime"
    "sync"
    "time"

    "github.com/ethereum/go-ethereum/accounts"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/event"
)

var (
    ErrLocked  = accounts.NewAuthNeededError("password or unlock")
    ErrNoMatch = errors.New("no key for given address or file")
    ErrDecrypt = errors.New("could not decrypt key with given passphrase")
)

// KeyStoreType is the reflect type of a keystore backend.
var KeyStoreType = reflect.TypeOf(&KeyStore{})

// KeyStoreScheme is the protocol scheme prefixing account and wallet URLs.
var KeyStoreScheme = "keystore"

// Maximum time between wallet refreshes (if filesystem notifications don't work).
const walletRefreshCycle = 3 * time.Second

// KeyStore manages a key storage directory on disk.
type KeyStore struct {
    storage  keyStore                     // Storage backend, might be cleartext or encrypted
    cache    *accountCache                // In-memory account cache over the filesystem storage
    changes  chan struct{}                // Channel receiving change notifications from the cache
    unlocked map[common.Address]*unlocked // Currently unlocked account (decrypted private keys)

    wallets     []accounts.Wallet       // Wallet wrappers around the individual key files
    updateFeed  event.Feed              // Event feed to notify wallet additions/removals
    updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
    updating    bool                    // Whether the event notification loop is running

    mu sync.RWMutex
}

type unlocked struct {
    *Key
    abort chan struct{}
}

// NewKeyStore creates a keystore for the given directory.
func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
    keydir, _ = filepath.Abs(keydir)
    ks := &KeyStore{storage: &keyStorePassphrase{keydir, scryptN, scryptP}}
    ks.init(keydir)
    return ks
}

// NewPlaintextKeyStore creates a keystore for the given directory.
// Deprecated: Use NewKeyStore.
func NewPlaintextKeyStore(keydir string) *KeyStore {
    keydir, _ = filepath.Abs(keydir)
    ks := &KeyStore{storage: &keyStorePlain{keydir}}
    ks.init(keydir)
    return ks
}

func (ks *KeyStore) init(keydir string) {
    // Lock the mutex since the account cache might call back with events
    ks.mu.Lock()
    defer ks.mu.Unlock()

    // Initialize the set of unlocked keys and the account cache
    ks.unlocked = make(map[common.Address]*unlocked)
    ks.cache, ks.changes = newAccountCache(keydir)

    // TODO: In order for this finalizer to work, there must be no references
    // to ks. addressCache doesn't keep a reference but unlocked keys do,
    // so the finalizer will not trigger until all timed unlocks have expired.
    runtime.SetFinalizer(ks, func(m *KeyStore) {
        m.cache.close()
    })
    // Create the initial list of wallets from the cache
    accs := ks.cache.accounts()
    ks.wallets = make([]accounts.Wallet, len(accs))
    for i := 0; i < len(accs); i++ {
        ks.wallets[i] = &keystoreWallet{account: accs[i], keystore: ks}
    }
}

// Wallets implements accounts.Backend, returning all single-key wallets from the
// keystore directory.
func (ks *KeyStore) Wallets() []accounts.Wallet {
    // Make sure the list of wallets is in sync with the account cache
    ks.refreshWallets()

    ks.mu.RLock()
    defer ks.mu.RUnlock()

    cpy := make([]accounts.Wallet, len(ks.wallets))
    copy(cpy, ks.wallets)
    return cpy
}

// refreshWallets retrieves the current account list and based on that does any
// necessary wallet refreshes.
func (ks *KeyStore) refreshWallets() {
    // Retrieve the current list of accounts
    ks.mu.Lock()
    accs := ks.cache.accounts()

    // Transform the current list of wallets into the new one
    wallets := make([]accounts.Wallet, 0, len(accs))
    events := []accounts.WalletEvent{}

    for _, account := range accs {
        // Drop wallets while they were in front of the next account
        for len(ks.wallets) > 0 && ks.wallets[0].URL().Cmp(account.URL) < 0 {
            events = append(events, accounts.WalletEvent{Wallet: ks.wallets[0], Kind: accounts.WalletDropped})
            ks.wallets = ks.wallets[1:]
        }
        // If there are no more wallets or the account is before the next, wrap new wallet
        if len(ks.wallets) == 0 || ks.wallets[0].URL().Cmp(account.URL) > 0 {
            wallet := &keystoreWallet{account: account, keystore: ks}

            events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
            wallets = append(wallets, wallet)
            continue
        }
        // If the account is the same as the first wallet, keep it
        if ks.wallets[0].Accounts()[0] == account {
            wallets = append(wallets, ks.wallets[0])
            ks.wallets = ks.wallets[1:]
            continue
        }
    }
    // Drop any leftover wallets and set the new batch
    for _, wallet := range ks.wallets {
        events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
    }
    ks.wallets = wallets
    ks.mu.Unlock()

    // Fire all wallet events and return
    for _, event := range events {
        ks.updateFeed.Send(event)
    }
}

// Subscribe implements accounts.Backend, creating an async subscription to
// receive notifications on the addition or removal of keystore wallets.
func (ks *KeyStore) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
    // We need the mutex to reliably start/stop the update loop
    ks.mu.Lock()
    defer ks.mu.Unlock()

    // Subscribe the caller and track the subscriber count
    sub := ks.updateScope.Track(ks.updateFeed.Subscribe(sink))

    // Subscribers require an active notification loop, start it
    if !ks.updating {
        ks.updating = true
        go ks.updater()
    }
    return sub
}

// updater is responsible for maintaining an up-to-date list of wallets stored in
// the keystore, and for firing wallet addition/removal events. It listens for
// account change events from the underlying account cache, and also periodically
// forces a manual refresh (only triggers for systems where the filesystem notifier
// is not running).
func (ks *KeyStore) updater() {
    for {
        // Wait for an account update or a refresh timeout
        select {
        case <-ks.changes:
        case <-time.After(walletRefreshCycle):
        }
        // Run the wallet refresher
        ks.refreshWallets()

        // If all our subscribers left, stop the updater
        ks.mu.Lock()
        if ks.updateScope.Count() == 0 {
            ks.updating = false
            ks.mu.Unlock()
            return
        }
        ks.mu.Unlock()
    }
}

// HasAddress reports whether a key with the given address is present.
func (ks *KeyStore) HasAddress(addr common.Address) bool {
    return ks.cache.hasAddress(addr)
}

// Accounts returns all key files present in the directory.
func (ks *KeyStore) Accounts() []accounts.Account {
    return ks.cache.accounts()
}

// Delete deletes the key matched by account if the passphrase is correct.
// If the account contains no filename, the address must match a unique key.
func (ks *KeyStore) Delete(a accounts.Account, passphrase string) error {
    // Decrypting the key isn't really necessary, but we do
    // it anyway to check the password and zero out the key
    // immediately afterwards.
    a, key, err := ks.getDecryptedKey(a, passphrase)
    if key != nil {
        zeroKey(key.PrivateKey)
    }
    if err != nil {
        return err
    }
    // The order is crucial here. The key is dropped from the
    // cache after the file is gone so that a reload happening in
    // between won't insert it into the cache again.
    err = os.Remove(a.URL.Path)
    if err == nil {
        ks.cache.delete(a)
        ks.refreshWallets()
    }
    return err
}

// SignHash calculates a ECDSA signature for the given hash. The produced
// signature is in the [R || S || V] format where V is 0 or 1.
func (ks *KeyStore) SignHash(a accounts.Account, hash []byte) ([]byte, error) {
    // Look up the key to sign with and abort if it cannot be found
    ks.mu.RLock()
    defer ks.mu.RUnlock()

    unlockedKey, found := ks.unlocked[a.Address]
    if !found {
        return nil, ErrLocked
    }
    // Sign the hash using plain ECDSA operations
    return crypto.Sign(hash, unlockedKey.PrivateKey)
}

// SignTx signs the given transaction with the requested account.
func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
    // Look up the key to sign with and abort if it cannot be found
    ks.mu.RLock()
    defer ks.mu.RUnlock()

    unlockedKey, found := ks.unlocked[a.Address]
    if !found {
        return nil, ErrLocked
    }
    // Depending on the presence of the chain ID, sign with EIP155 or homestead
    if chainID != nil {
        return types.SignTx(tx, types.NewEIP155Signer(chainID), unlockedKey.PrivateKey)
    }
    return types.SignTx(tx, types.HomesteadSigner{}, unlockedKey.PrivateKey)
}

// SignHashWithPassphrase signs hash if the private key matching the given address
// can be decrypted with the given passphrase. The produced signature is in the
// [R || S || V] format where V is 0 or 1.
func (ks *KeyStore) SignHashWithPassphrase(a accounts.Account, passphrase string, hash []byte) (signature []byte, err error) {
    _, key, err := ks.getDecryptedKey(a, passphrase)
    if err != nil {
        return nil, err
    }
    defer zeroKey(key.PrivateKey)
    return crypto.Sign(hash, key.PrivateKey)
}

// SignTxWithPassphrase signs the transaction if the private key matching the
// given address can be decrypted with the given passphrase.
func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
    _, key, err := ks.getDecryptedKey(a, passphrase)
    if err != nil {
        return nil, err
    }
    defer zeroKey(key.PrivateKey)

    // Depending on the presence of the chain ID, sign with EIP155 or homestead
    if chainID != nil {
        return types.SignTx(tx, types.NewEIP155Signer(chainID), key.PrivateKey)
    }
    return types.SignTx(tx, types.HomesteadSigner{}, key.PrivateKey)
}

// Unlock unlocks the given account indefinitely.
func (ks *KeyStore) Unlock(a accounts.Account, passphrase string) error {
    return ks.TimedUnlock(a, passphrase, 0)
}

// Lock removes the private key with the given address from memory.
func (ks *KeyStore) Lock(addr common.Address) error {
    ks.mu.Lock()
    if unl, found := ks.unlocked[addr]; found {
        ks.mu.Unlock()
        ks.expire(addr, unl, time.Duration(0)*time.Nanosecond)
    } else {
        ks.mu.Unlock()
    }
    return nil
}

// TimedUnlock unlocks the given account with the passphrase. The account
// stays unlocked for the duration of timeout. A timeout of 0 unlocks the account
// until the program exits. The account must match a unique key file.
//
// If the account address is already unlocked for a duration, TimedUnlock extends or
// shortens the active unlock timeout. If the address was previously unlocked
// indefinitely the timeout is not altered.
func (ks *KeyStore) TimedUnlock(a accounts.Account, passphrase string, timeout time.Duration) error {
    a, key, err := ks.getDecryptedKey(a, passphrase)
    if err != nil {
        return err
    }

    ks.mu.Lock()
    defer ks.mu.Unlock()
    u, found := ks.unlocked[a.Address]
    if found {
        if u.abort == nil {
            // The address was unlocked indefinitely, so unlocking
            // it with a timeout would be confusing.
            zeroKey(key.PrivateKey)
            return nil
        }
        // Terminate the expire goroutine and replace it below.
        close(u.abort)
    }
    if timeout > 0 {
        u = &unlocked{Key: key, abort: make(chan struct{})}
        go ks.expire(a.Address, u, timeout)
    } else {
        u = &unlocked{Key: key}
    }
    ks.unlocked[a.Address] = u
    return nil
}

// Find resolves the given account into a unique entry in the keystore.
func (ks *KeyStore) Find(a accounts.Account) (accounts.Account, error) {
    ks.cache.maybeReload()
    ks.cache.mu.Lock()
    a, err := ks.cache.find(a)
    ks.cache.mu.Unlock()
    return a, err
}

func (ks *KeyStore) getDecryptedKey(a accounts.Account, auth string) (accounts.Account, *Key, error) {
    a, err := ks.Find(a)
    if err != nil {
        return a, nil, err
    }
    key, err := ks.storage.GetKey(a.Address, a.URL.Path, auth)
    return a, key, err
}

func (ks *KeyStore) expire(addr common.Address, u *unlocked, timeout time.Duration) {
    t := time.NewTimer(timeout)
    defer t.Stop()
    select {
    case <-u.abort:
        // just quit
    case <-t.C:
        ks.mu.Lock()
        // only drop if it's still the same key instance that dropLater
        // was launched with. we can check that using pointer equality
        // because the map stores a new pointer every time the key is
        // unlocked.
        if ks.unlocked[addr] == u {
            zeroKey(u.PrivateKey)
            delete(ks.unlocked, addr)
        }
        ks.mu.Unlock()
    }
}

// NewAccount generates a new key and stores it into the key directory,
// encrypting it with the passphrase.
func (ks *KeyStore) NewAccount(passphrase string) (accounts.Account, error) {
    _, account, err := storeNewKey(ks.storage, crand.Reader, passphrase)
    if err != nil {
        return accounts.Account{}, err
    }
    // Add the account to the cache immediately rather
    // than waiting for file system notifications to pick it up.
    ks.cache.add(account)
    ks.refreshWallets()
    return account, nil
}

// Export exports as a JSON key, encrypted with newPassphrase.
func (ks *KeyStore) Export(a accounts.Account, passphrase, newPassphrase string) (keyJSON []byte, err error) {
    _, key, err := ks.getDecryptedKey(a, passphrase)
    if err != nil {
        return nil, err
    }
    var N, P int
    if store, ok := ks.storage.(*keyStorePassphrase); ok {
        N, P = store.scryptN, store.scryptP
    } else {
        N, P = StandardScryptN, StandardScryptP
    }
    return EncryptKey(key, newPassphrase, N, P)
}

// Import stores the given encrypted JSON key into the key directory.
func (ks *KeyStore) Import(keyJSON []byte, passphrase, newPassphrase string) (accounts.Account, error) {
    key, err := DecryptKey(keyJSON, passphrase)
    if key != nil && key.PrivateKey != nil {
        defer zeroKey(key.PrivateKey)
    }
    if err != nil {
        return accounts.Account{}, err
    }
    return ks.importKey(key, newPassphrase)
}

// ImportECDSA stores the given key into the key directory, encrypting it with the passphrase.
func (ks *KeyStore) ImportECDSA(priv *ecdsa.PrivateKey, passphrase string) (accounts.Account, error) {
    key := newKeyFromECDSA(priv)
    if ks.cache.hasAddress(key.Address) {
        return accounts.Account{}, fmt.Errorf("account already exists")
    }
    return ks.importKey(key, passphrase)
}

func (ks *KeyStore) importKey(key *Key, passphrase string) (accounts.Account, error) {
    a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.storage.JoinPath(keyFileName(key.Address))}}
    if err := ks.storage.StoreKey(a.URL.Path, key, passphrase); err != nil {
        return accounts.Account{}, err
    }
    ks.cache.add(a)
    ks.refreshWallets()
    return a, nil
}

// Update changes the passphrase of an existing account.
func (ks *KeyStore) Update(a accounts.Account, passphrase, newPassphrase string) error {
    a, key, err := ks.getDecryptedKey(a, passphrase)
    if err != nil {
        return err
    }
    return ks.storage.StoreKey(a.URL.Path, key, newPassphrase)
}

// ImportPreSaleKey decrypts the given Ethereum presale wallet and stores
// a key file in the key directory. The key file is encrypted with the same passphrase.
func (ks *KeyStore) ImportPreSaleKey(keyJSON []byte, passphrase string) (accounts.Account, error) {
    a, _, err := importPreSaleKey(ks.storage, keyJSON, passphrase)
    if err != nil {
        return a, err
    }
    ks.cache.add(a)
    ks.refreshWallets()
    return a, nil
}

// zeroKey zeroes a private key in memory.
func zeroKey(k *ecdsa.PrivateKey) {
    b := k.D.Bits()
    for i := range b {
        b[i] = 0
    }
}