9e5f03b6c4
With this commit, core/state's access to the underlying key/value database is mediated through an interface. Database errors are tracked in StateDB and returned by CommitTo or the new Error method. Motivation for this change: We can remove the light client's duplicated copy of core/state. The light client now supports node iteration, so tracing and storage enumeration can work with the light client (not implemented in this commit).
219 lines
7.3 KiB
Go
219 lines
7.3 KiB
Go
// Copyright 2015 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 trie
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
)
|
|
|
|
var secureKeyPrefix = []byte("secure-key-")
|
|
|
|
const secureKeyLength = 11 + 32 // Length of the above prefix + 32byte hash
|
|
|
|
// SecureTrie wraps a trie with key hashing. In a secure trie, all
|
|
// access operations hash the key using keccak256. This prevents
|
|
// calling code from creating long chains of nodes that
|
|
// increase the access time.
|
|
//
|
|
// Contrary to a regular trie, a SecureTrie can only be created with
|
|
// New and must have an attached database. The database also stores
|
|
// the preimage of each key.
|
|
//
|
|
// SecureTrie is not safe for concurrent use.
|
|
type SecureTrie struct {
|
|
trie Trie
|
|
hashKeyBuf [secureKeyLength]byte
|
|
secKeyBuf [200]byte
|
|
secKeyCache map[string][]byte
|
|
secKeyCacheOwner *SecureTrie // Pointer to self, replace the key cache on mismatch
|
|
}
|
|
|
|
// NewSecure creates a trie with an existing root node from db.
|
|
//
|
|
// If root is the zero hash or the sha3 hash of an empty string, the
|
|
// trie is initially empty. Otherwise, New will panic if db is nil
|
|
// and returns MissingNodeError if the root node cannot be found.
|
|
//
|
|
// Accessing the trie loads nodes from db on demand.
|
|
// Loaded nodes are kept around until their 'cache generation' expires.
|
|
// A new cache generation is created by each call to Commit.
|
|
// cachelimit sets the number of past cache generations to keep.
|
|
func NewSecure(root common.Hash, db Database, cachelimit uint16) (*SecureTrie, error) {
|
|
if db == nil {
|
|
panic("NewSecure called with nil database")
|
|
}
|
|
trie, err := New(root, db)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
trie.SetCacheLimit(cachelimit)
|
|
return &SecureTrie{trie: *trie}, nil
|
|
}
|
|
|
|
// Get returns the value for key stored in the trie.
|
|
// The value bytes must not be modified by the caller.
|
|
func (t *SecureTrie) Get(key []byte) []byte {
|
|
res, err := t.TryGet(key)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
return res
|
|
}
|
|
|
|
// TryGet returns the value for key stored in the trie.
|
|
// The value bytes must not be modified by the caller.
|
|
// If a node was not found in the database, a MissingNodeError is returned.
|
|
func (t *SecureTrie) TryGet(key []byte) ([]byte, error) {
|
|
return t.trie.TryGet(t.hashKey(key))
|
|
}
|
|
|
|
// Update associates key with value in the trie. Subsequent calls to
|
|
// Get will return value. If value has length zero, any existing value
|
|
// is deleted from the trie and calls to Get will return nil.
|
|
//
|
|
// The value bytes must not be modified by the caller while they are
|
|
// stored in the trie.
|
|
func (t *SecureTrie) Update(key, value []byte) {
|
|
if err := t.TryUpdate(key, value); err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
}
|
|
|
|
// TryUpdate associates key with value in the trie. Subsequent calls to
|
|
// Get will return value. If value has length zero, any existing value
|
|
// is deleted from the trie and calls to Get will return nil.
|
|
//
|
|
// The value bytes must not be modified by the caller while they are
|
|
// stored in the trie.
|
|
//
|
|
// If a node was not found in the database, a MissingNodeError is returned.
|
|
func (t *SecureTrie) TryUpdate(key, value []byte) error {
|
|
hk := t.hashKey(key)
|
|
err := t.trie.TryUpdate(hk, value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t.getSecKeyCache()[string(hk)] = common.CopyBytes(key)
|
|
return nil
|
|
}
|
|
|
|
// Delete removes any existing value for key from the trie.
|
|
func (t *SecureTrie) Delete(key []byte) {
|
|
if err := t.TryDelete(key); err != nil {
|
|
log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
|
|
}
|
|
}
|
|
|
|
// TryDelete removes any existing value for key from the trie.
|
|
// If a node was not found in the database, a MissingNodeError is returned.
|
|
func (t *SecureTrie) TryDelete(key []byte) error {
|
|
hk := t.hashKey(key)
|
|
delete(t.getSecKeyCache(), string(hk))
|
|
return t.trie.TryDelete(hk)
|
|
}
|
|
|
|
// GetKey returns the sha3 preimage of a hashed key that was
|
|
// previously used to store a value.
|
|
func (t *SecureTrie) GetKey(shaKey []byte) []byte {
|
|
if key, ok := t.getSecKeyCache()[string(shaKey)]; ok {
|
|
return key
|
|
}
|
|
key, _ := t.trie.db.Get(t.secKey(shaKey))
|
|
return key
|
|
}
|
|
|
|
// Commit writes all nodes and the secure hash pre-images to the trie's database.
|
|
// Nodes are stored with their sha3 hash as the key.
|
|
//
|
|
// Committing flushes nodes from memory. Subsequent Get calls will load nodes
|
|
// from the database.
|
|
func (t *SecureTrie) Commit() (root common.Hash, err error) {
|
|
return t.CommitTo(t.trie.db)
|
|
}
|
|
|
|
func (t *SecureTrie) Hash() common.Hash {
|
|
return t.trie.Hash()
|
|
}
|
|
|
|
func (t *SecureTrie) Root() []byte {
|
|
return t.trie.Root()
|
|
}
|
|
|
|
func (t *SecureTrie) Copy() *SecureTrie {
|
|
cpy := *t
|
|
return &cpy
|
|
}
|
|
|
|
// NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration
|
|
// starts at the key after the given start key.
|
|
func (t *SecureTrie) NodeIterator(start []byte) NodeIterator {
|
|
return t.trie.NodeIterator(start)
|
|
}
|
|
|
|
// CommitTo writes all nodes and the secure hash pre-images to the given database.
|
|
// Nodes are stored with their sha3 hash as the key.
|
|
//
|
|
// Committing flushes nodes from memory. Subsequent Get calls will load nodes from
|
|
// the trie's database. Calling code must ensure that the changes made to db are
|
|
// written back to the trie's attached database before using the trie.
|
|
func (t *SecureTrie) CommitTo(db DatabaseWriter) (root common.Hash, err error) {
|
|
if len(t.getSecKeyCache()) > 0 {
|
|
for hk, key := range t.secKeyCache {
|
|
if err := db.Put(t.secKey([]byte(hk)), key); err != nil {
|
|
return common.Hash{}, err
|
|
}
|
|
}
|
|
t.secKeyCache = make(map[string][]byte)
|
|
}
|
|
return t.trie.CommitTo(db)
|
|
}
|
|
|
|
// secKey returns the database key for the preimage of key, as an ephemeral buffer.
|
|
// The caller must not hold onto the return value because it will become
|
|
// invalid on the next call to hashKey or secKey.
|
|
func (t *SecureTrie) secKey(key []byte) []byte {
|
|
buf := append(t.secKeyBuf[:0], secureKeyPrefix...)
|
|
buf = append(buf, key...)
|
|
return buf
|
|
}
|
|
|
|
// hashKey returns the hash of key as an ephemeral buffer.
|
|
// The caller must not hold onto the return value because it will become
|
|
// invalid on the next call to hashKey or secKey.
|
|
func (t *SecureTrie) hashKey(key []byte) []byte {
|
|
h := newHasher(0, 0)
|
|
h.sha.Reset()
|
|
h.sha.Write(key)
|
|
buf := h.sha.Sum(t.hashKeyBuf[:0])
|
|
returnHasherToPool(h)
|
|
return buf
|
|
}
|
|
|
|
// getSecKeyCache returns the current secure key cache, creating a new one if
|
|
// ownership changed (i.e. the current secure trie is a copy of another owning
|
|
// the actual cache).
|
|
func (t *SecureTrie) getSecKeyCache() map[string][]byte {
|
|
if t != t.secKeyCacheOwner {
|
|
t.secKeyCacheOwner = t
|
|
t.secKeyCache = make(map[string][]byte)
|
|
}
|
|
return t.secKeyCache
|
|
}
|