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 }