gitlab.com/yannislg/go-pulse@v0.0.0-20210722055913-a3e24e95638d/core/forkid/forkid.go (about) 1 // Copyright 2019 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 forkid implements EIP-2124 (https://eips.ethereum.org/EIPS/eip-2124). 18 package forkid 19 20 import ( 21 "encoding/binary" 22 "errors" 23 "hash/crc32" 24 "math" 25 "math/big" 26 "reflect" 27 "strings" 28 29 "github.com/ethereum/go-ethereum/common" 30 "github.com/ethereum/go-ethereum/core" 31 "github.com/ethereum/go-ethereum/log" 32 "github.com/ethereum/go-ethereum/params" 33 ) 34 35 var ( 36 // ErrRemoteStale is returned by the validator if a remote fork checksum is a 37 // subset of our already applied forks, but the announced next fork block is 38 // not on our already passed chain. 39 ErrRemoteStale = errors.New("remote needs update") 40 41 // ErrLocalIncompatibleOrStale is returned by the validator if a remote fork 42 // checksum does not match any local checksum variation, signalling that the 43 // two chains have diverged in the past at some point (possibly at genesis). 44 ErrLocalIncompatibleOrStale = errors.New("local incompatible or needs update") 45 ) 46 47 // ID is a fork identifier as defined by EIP-2124. 48 type ID struct { 49 Hash [4]byte // CRC32 checksum of the genesis block and passed fork block numbers 50 Next uint64 // Block number of the next upcoming fork, or 0 if no forks are known 51 } 52 53 // Filter is a fork id filter to validate a remotely advertised ID. 54 type Filter func(id ID) error 55 56 // NewID calculates the Ethereum fork ID from the chain config and head. 57 func NewID(chain *core.BlockChain) ID { 58 return newID( 59 chain.Config(), 60 chain.Genesis().Hash(), 61 chain.CurrentHeader().Number.Uint64(), 62 ) 63 } 64 65 func NextForkHash(config *params.ChainConfig, genesis common.Hash, head uint64) [4]byte { 66 // Calculate the starting checksum from the genesis hash 67 hash := crc32.ChecksumIEEE(genesis[:]) 68 69 // Calculate the current fork checksum and the next fork block 70 var next uint64 71 for _, fork := range gatherForks(config) { 72 if fork <= head { 73 // Fork already passed, checksum the previous hash and the fork number 74 hash = checksumUpdate(hash, fork) 75 continue 76 } 77 next = fork 78 break 79 } 80 if next == 0 { 81 return checksumToBytes(hash) 82 } else { 83 return checksumToBytes(checksumUpdate(hash, next)) 84 } 85 } 86 87 // newID is the internal version of NewID, which takes extracted values as its 88 // arguments instead of a chain. The reason is to allow testing the IDs without 89 // having to simulate an entire blockchain. 90 func newID(config *params.ChainConfig, genesis common.Hash, head uint64) ID { 91 // Calculate the starting checksum from the genesis hash 92 hash := crc32.ChecksumIEEE(genesis[:]) 93 94 // Calculate the current fork checksum and the next fork block 95 var next uint64 96 for _, fork := range gatherForks(config) { 97 if fork <= head { 98 // Fork already passed, checksum the previous hash and the fork number 99 hash = checksumUpdate(hash, fork) 100 continue 101 } 102 next = fork 103 break 104 } 105 return ID{Hash: checksumToBytes(hash), Next: next} 106 } 107 108 // NewFilter creates a filter that returns if a fork ID should be rejected or not 109 // based on the local chain's status. 110 func NewFilter(chain *core.BlockChain) Filter { 111 return newFilter( 112 chain.Config(), 113 chain.Genesis().Hash(), 114 func() uint64 { 115 return chain.CurrentHeader().Number.Uint64() 116 }, 117 ) 118 } 119 120 // NewStaticFilter creates a filter at block zero. 121 func NewStaticFilter(config *params.ChainConfig, genesis common.Hash) Filter { 122 head := func() uint64 { return 0 } 123 return newFilter(config, genesis, head) 124 } 125 126 // newFilter is the internal version of NewFilter, taking closures as its arguments 127 // instead of a chain. The reason is to allow testing it without having to simulate 128 // an entire blockchain. 129 func newFilter(config *params.ChainConfig, genesis common.Hash, headfn func() uint64) Filter { 130 // Calculate the all the valid fork hash and fork next combos 131 var ( 132 forks = gatherForks(config) 133 sums = make([][4]byte, len(forks)+1) // 0th is the genesis 134 ) 135 hash := crc32.ChecksumIEEE(genesis[:]) 136 sums[0] = checksumToBytes(hash) 137 for i, fork := range forks { 138 hash = checksumUpdate(hash, fork) 139 sums[i+1] = checksumToBytes(hash) 140 } 141 // Add two sentries to simplify the fork checks and don't require special 142 // casing the last one. 143 forks = append(forks, math.MaxUint64) // Last fork will never be passed 144 145 // Create a validator that will filter out incompatible chains 146 return func(id ID) error { 147 // Run the fork checksum validation ruleset: 148 // 1. If local and remote FORK_CSUM matches, compare local head to FORK_NEXT. 149 // The two nodes are in the same fork state currently. They might know 150 // of differing future forks, but that's not relevant until the fork 151 // triggers (might be postponed, nodes might be updated to match). 152 // 1a. A remotely announced but remotely not passed block is already passed 153 // locally, disconnect, since the chains are incompatible. 154 // 1b. No remotely announced fork; or not yet passed locally, connect. 155 // 2. If the remote FORK_CSUM is a subset of the local past forks and the 156 // remote FORK_NEXT matches with the locally following fork block number, 157 // connect. 158 // Remote node is currently syncing. It might eventually diverge from 159 // us, but at this current point in time we don't have enough information. 160 // 3. If the remote FORK_CSUM is a superset of the local past forks and can 161 // be completed with locally known future forks, connect. 162 // Local node is currently syncing. It might eventually diverge from 163 // the remote, but at this current point in time we don't have enough 164 // information. 165 // 4. Reject in all other cases. 166 head := headfn() 167 for i, fork := range forks { 168 // If our head is beyond this fork, continue to the next (we have a dummy 169 // fork of maxuint64 as the last item to always fail this check eventually). 170 if head >= fork { 171 continue 172 } 173 // Found the first unpassed fork block, check if our current state matches 174 // the remote checksum (rule #1). 175 if sums[i] == id.Hash { 176 // Fork checksum matched, check if a remote future fork block already passed 177 // locally without the local node being aware of it (rule #1a). 178 if id.Next > 0 && head >= id.Next { 179 return ErrLocalIncompatibleOrStale 180 } 181 // Haven't passed locally a remote-only fork, accept the connection (rule #1b). 182 return nil 183 } 184 // The local and remote nodes are in different forks currently, check if the 185 // remote checksum is a subset of our local forks (rule #2). 186 for j := 0; j < i; j++ { 187 if sums[j] == id.Hash { 188 // Remote checksum is a subset, validate based on the announced next fork 189 if forks[j] != id.Next { 190 return ErrRemoteStale 191 } 192 return nil 193 } 194 } 195 // Remote chain is not a subset of our local one, check if it's a superset by 196 // any chance, signalling that we're simply out of sync (rule #3). 197 for j := i + 1; j < len(sums); j++ { 198 if sums[j] == id.Hash { 199 // Yay, remote checksum is a superset, ignore upcoming forks 200 return nil 201 } 202 } 203 // No exact, subset or superset match. We are on differing chains, reject. 204 return ErrLocalIncompatibleOrStale 205 } 206 log.Error("Impossible fork ID validation", "id", id) 207 return nil // Something's very wrong, accept rather than reject 208 } 209 } 210 211 // checksumUpdate calculates the next IEEE CRC32 checksum based on the previous 212 // one and a fork block number (equivalent to CRC32(original-blob || fork)). 213 func checksumUpdate(hash uint32, fork uint64) uint32 { 214 var blob [8]byte 215 binary.BigEndian.PutUint64(blob[:], fork) 216 return crc32.Update(hash, crc32.IEEETable, blob[:]) 217 } 218 219 // checksumToBytes converts a uint32 checksum into a [4]byte array. 220 func checksumToBytes(hash uint32) [4]byte { 221 var blob [4]byte 222 binary.BigEndian.PutUint32(blob[:], hash) 223 return blob 224 } 225 226 // gatherForks gathers all the known forks and creates a sorted list out of them. 227 func gatherForks(config *params.ChainConfig) []uint64 { 228 // Gather all the fork block numbers via reflection 229 kind := reflect.TypeOf(params.ChainConfig{}) 230 conf := reflect.ValueOf(config).Elem() 231 232 var forks []uint64 233 for i := 0; i < kind.NumField(); i++ { 234 // Fetch the next field and skip non-fork rules 235 field := kind.Field(i) 236 if !strings.HasSuffix(field.Name, "Block") { 237 continue 238 } 239 if field.Type != reflect.TypeOf(new(big.Int)) { 240 continue 241 } 242 // Extract the fork rule block number and aggregate it 243 rule := conf.Field(i).Interface().(*big.Int) 244 if rule != nil { 245 forks = append(forks, rule.Uint64()) 246 } 247 } 248 // Sort the fork block numbers to permit chronologival XOR 249 for i := 0; i < len(forks); i++ { 250 for j := i + 1; j < len(forks); j++ { 251 if forks[i] > forks[j] { 252 forks[i], forks[j] = forks[j], forks[i] 253 } 254 } 255 } 256 // Deduplicate block numbers applying multiple forks 257 for i := 1; i < len(forks); i++ { 258 if forks[i] == forks[i-1] { 259 forks = append(forks[:i], forks[i+1:]...) 260 i-- 261 } 262 } 263 // Skip any forks in block 0, that's the genesis ruleset 264 if len(forks) > 0 && forks[0] == 0 { 265 forks = forks[1:] 266 } 267 return forks 268 }