github.com/kisexp/xdchain@v0.0.0-20211206025815-490d6b732aa7/trie/secure_trie.go (about)

     1  // Copyright 2015 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 trie
    18  
    19  import (
    20  	"fmt"
    21  
    22  	"github.com/kisexp/xdchain/common"
    23  	"github.com/kisexp/xdchain/log"
    24  )
    25  
    26  // SecureTrie wraps a trie with key hashing. In a secure trie, all
    27  // access operations hash the key using keccak256. This prevents
    28  // calling code from creating long chains of nodes that
    29  // increase the access time.
    30  //
    31  // Contrary to a regular trie, a SecureTrie can only be created with
    32  // New and must have an attached database. The database also stores
    33  // the preimage of each key.
    34  //
    35  // SecureTrie is not safe for concurrent use.
    36  type SecureTrie struct {
    37  	trie             Trie
    38  	hashKeyBuf       [common.HashLength]byte
    39  	secKeyCache      map[string][]byte
    40  	secKeyCacheOwner *SecureTrie // Pointer to self, replace the key cache on mismatch
    41  }
    42  
    43  // NewSecure creates a trie with an existing root node from a backing database
    44  // and optional intermediate in-memory node pool.
    45  //
    46  // If root is the zero hash or the sha3 hash of an empty string, the
    47  // trie is initially empty. Otherwise, New will panic if db is nil
    48  // and returns MissingNodeError if the root node cannot be found.
    49  //
    50  // Accessing the trie loads nodes from the database or node pool on demand.
    51  // Loaded nodes are kept around until their 'cache generation' expires.
    52  // A new cache generation is created by each call to Commit.
    53  // cachelimit sets the number of past cache generations to keep.
    54  func NewSecure(root common.Hash, db *Database) (*SecureTrie, error) {
    55  	if db == nil {
    56  		panic("trie.NewSecure called without a database")
    57  	}
    58  	trie, err := New(root, db)
    59  	if err != nil {
    60  		return nil, err
    61  	}
    62  	return &SecureTrie{trie: *trie}, nil
    63  }
    64  
    65  // Get returns the value for key stored in the trie.
    66  // The value bytes must not be modified by the caller.
    67  func (t *SecureTrie) Get(key []byte) []byte {
    68  	res, err := t.TryGet(key)
    69  	if err != nil {
    70  		log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
    71  	}
    72  	return res
    73  }
    74  
    75  // TryGet returns the value for key stored in the trie.
    76  // The value bytes must not be modified by the caller.
    77  // If a node was not found in the database, a MissingNodeError is returned.
    78  func (t *SecureTrie) TryGet(key []byte) ([]byte, error) {
    79  	return t.trie.TryGet(t.hashKey(key))
    80  }
    81  
    82  // TryGetNode attempts to retrieve a trie node by compact-encoded path. It is not
    83  // possible to use keybyte-encoding as the path might contain odd nibbles.
    84  func (t *SecureTrie) TryGetNode(path []byte) ([]byte, int, error) {
    85  	return t.trie.TryGetNode(path)
    86  }
    87  
    88  // Update associates key with value in the trie. Subsequent calls to
    89  // Get will return value. If value has length zero, any existing value
    90  // is deleted from the trie and calls to Get will return nil.
    91  //
    92  // The value bytes must not be modified by the caller while they are
    93  // stored in the trie.
    94  func (t *SecureTrie) Update(key, value []byte) {
    95  	if err := t.TryUpdate(key, value); err != nil {
    96  		log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
    97  	}
    98  }
    99  
   100  // TryUpdate associates key with value in the trie. Subsequent calls to
   101  // Get will return value. If value has length zero, any existing value
   102  // is deleted from the trie and calls to Get will return nil.
   103  //
   104  // The value bytes must not be modified by the caller while they are
   105  // stored in the trie.
   106  //
   107  // If a node was not found in the database, a MissingNodeError is returned.
   108  func (t *SecureTrie) TryUpdate(key, value []byte) error {
   109  	hk := t.hashKey(key)
   110  	err := t.trie.TryUpdate(hk, value)
   111  	if err != nil {
   112  		return err
   113  	}
   114  	t.getSecKeyCache()[string(hk)] = common.CopyBytes(key)
   115  	return nil
   116  }
   117  
   118  // Delete removes any existing value for key from the trie.
   119  func (t *SecureTrie) Delete(key []byte) {
   120  	if err := t.TryDelete(key); err != nil {
   121  		log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
   122  	}
   123  }
   124  
   125  // TryDelete removes any existing value for key from the trie.
   126  // If a node was not found in the database, a MissingNodeError is returned.
   127  func (t *SecureTrie) TryDelete(key []byte) error {
   128  	hk := t.hashKey(key)
   129  	delete(t.getSecKeyCache(), string(hk))
   130  	return t.trie.TryDelete(hk)
   131  }
   132  
   133  // GetKey returns the sha3 preimage of a hashed key that was
   134  // previously used to store a value.
   135  func (t *SecureTrie) GetKey(shaKey []byte) []byte {
   136  	if key, ok := t.getSecKeyCache()[string(shaKey)]; ok {
   137  		return key
   138  	}
   139  	return t.trie.db.preimage(common.BytesToHash(shaKey))
   140  }
   141  
   142  // Commit writes all nodes and the secure hash pre-images to the trie's database.
   143  // Nodes are stored with their sha3 hash as the key.
   144  //
   145  // Committing flushes nodes from memory. Subsequent Get calls will load nodes
   146  // from the database.
   147  func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
   148  	// Write all the pre-images to the actual disk database
   149  	if len(t.getSecKeyCache()) > 0 {
   150  		if t.trie.db.preimages != nil { // Ugly direct check but avoids the below write lock
   151  			t.trie.db.lock.Lock()
   152  			for hk, key := range t.secKeyCache {
   153  				t.trie.db.insertPreimage(common.BytesToHash([]byte(hk)), key)
   154  			}
   155  			t.trie.db.lock.Unlock()
   156  		}
   157  		t.secKeyCache = make(map[string][]byte)
   158  	}
   159  	// Commit the trie to its intermediate node database
   160  	return t.trie.Commit(onleaf)
   161  }
   162  
   163  // Hash returns the root hash of SecureTrie. It does not write to the
   164  // database and can be used even if the trie doesn't have one.
   165  func (t *SecureTrie) Hash() common.Hash {
   166  	return t.trie.Hash()
   167  }
   168  
   169  // Copy returns a copy of SecureTrie.
   170  func (t *SecureTrie) Copy() *SecureTrie {
   171  	cpy := *t
   172  	return &cpy
   173  }
   174  
   175  // NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration
   176  // starts at the key after the given start key.
   177  func (t *SecureTrie) NodeIterator(start []byte) NodeIterator {
   178  	return t.trie.NodeIterator(start)
   179  }
   180  
   181  // hashKey returns the hash of key as an ephemeral buffer.
   182  // The caller must not hold onto the return value because it will become
   183  // invalid on the next call to hashKey or secKey.
   184  func (t *SecureTrie) hashKey(key []byte) []byte {
   185  	h := newHasher(false)
   186  	h.sha.Reset()
   187  	h.sha.Write(key)
   188  	h.sha.Read(t.hashKeyBuf[:])
   189  	returnHasherToPool(h)
   190  	return t.hashKeyBuf[:]
   191  }
   192  
   193  // getSecKeyCache returns the current secure key cache, creating a new one if
   194  // ownership changed (i.e. the current secure trie is a copy of another owning
   195  // the actual cache).
   196  func (t *SecureTrie) getSecKeyCache() map[string][]byte {
   197  	if t != t.secKeyCacheOwner {
   198  		t.secKeyCacheOwner = t
   199  		t.secKeyCache = make(map[string][]byte)
   200  	}
   201  	return t.secKeyCache
   202  }