From 6362a9d6102b26e926b3e73563267fc75cb30f9c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Wed, 29 Jun 2016 11:44:51 +0300 Subject: Revert "test, cmd/evm, core, core/vm: illegal code hash implementation" This reverts commit 7a5b571c671e70e0e4807cf971c15e2d1e09d33d. --- core/execution.go | 5 ----- core/state/statedb.go | 10 ---------- core/state_processor.go | 24 +++--------------------- core/vm/environment.go | 3 --- core/vm/jit_test.go | 9 ++++----- core/vm/runtime/env.go | 26 +++++++++++--------------- core/vm/runtime/runtime.go | 23 +++++++++++------------ core/vm_env.go | 6 ------ 8 files changed, 29 insertions(+), 77 deletions(-) (limited to 'core') diff --git a/core/execution.go b/core/execution.go index ec04f6140..82143443c 100644 --- a/core/execution.go +++ b/core/execution.go @@ -85,11 +85,6 @@ func exec(env vm.Environment, caller vm.ContractRef, address, codeAddr *common.A createAccount = true } - // mark the code hash if the execution is a call, callcode or delegate. - if value.Cmp(common.Big0) > 0 { - env.MarkCodeHash(env.Db().GetCodeHash(caller.Address())) - } - snapshotPreTransfer := env.MakeSnapshot() var ( from = env.Db().GetAccount(caller.Address()) diff --git a/core/state/statedb.go b/core/state/statedb.go index 79cbbaee8..3e25e0c16 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -51,8 +51,6 @@ type StateDB struct { txIndex int logs map[common.Hash]vm.Logs logSize uint - - reducedDao bool } // Create a new state from a given trie @@ -163,14 +161,6 @@ func (self *StateDB) GetCode(addr common.Address) []byte { return nil } -func (self *StateDB) GetCodeHash(addr common.Address) common.Hash { - stateObject := self.GetStateObject(addr) - if stateObject != nil { - return common.BytesToHash(stateObject.codeHash) - } - return common.Hash{} -} - func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash { stateObject := self.GetStateObject(a) if stateObject != nil { diff --git a/core/state_processor.go b/core/state_processor.go index 55c1301eb..95b3057bb 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -17,10 +17,8 @@ package core import ( - "errors" "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -30,15 +28,8 @@ import ( ) var ( - big8 = big.NewInt(8) - big32 = big.NewInt(32) - illegalCodeHashErr = errors.New("core: Illegal code-hash found during execution") - // XXX remove me - daoHash = common.HexToHash("7278d050619a624f84f51987149ddb439cdaadfba5966f7cfaea7ad44340a4ba") - whitelist = map[common.Address]bool{ - common.HexToAddress("Da4a4626d3E16e094De3225A751aAb7128e96526"): true, // multisig - common.HexToAddress("2ba9D006C1D72E67A70b5526Fc6b4b0C0fd6D334"): true, // attack contract - } + big8 = big.NewInt(8) + big32 = big.NewInt(32) ) // StateProcessor is a basic Processor, which takes care of transitioning @@ -95,20 +86,11 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg // ApplyTransactions returns the generated receipts and vm logs during the // execution of the state transition phase. func ApplyTransaction(config *ChainConfig, bc *BlockChain, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, vm.Logs, *big.Int, error) { - env := NewEnv(statedb, config, bc, tx, header, cfg) - _, gas, err := ApplyMessage(env, tx, gp) + _, gas, err := ApplyMessage(NewEnv(statedb, config, bc, tx, header, cfg), tx, gp) if err != nil { return nil, nil, nil, err } - for _, codeHash := range env.CodeHashes { - _, illegalHash := IllegalCodeHashes[codeHash] - to := tx.To() - if illegalHash && to != nil && !whitelist[*to] { - return nil, nil, nil, illegalCodeHashErr - } - } - // Update the state with pending changes usedGas.Add(usedGas, gas) receipt := types.NewReceipt(statedb.IntermediateRoot().Bytes(), usedGas) diff --git a/core/vm/environment.go b/core/vm/environment.go index 37817be9e..747627565 100644 --- a/core/vm/environment.go +++ b/core/vm/environment.go @@ -73,8 +73,6 @@ type Environment interface { DelegateCall(me ContractRef, addr common.Address, data []byte, gas, price *big.Int) ([]byte, error) // Create a new contract Create(me ContractRef, data []byte, gas, price, value *big.Int) ([]byte, common.Address, error) - // Mark the code hash that was executed - MarkCodeHash(hash common.Hash) } // Vm is the basic interface for an implementation of the EVM. @@ -98,7 +96,6 @@ type Database interface { GetCode(common.Address) []byte SetCode(common.Address, []byte) - GetCodeHash(common.Address) common.Hash AddRefund(*big.Int) GetRefund() *big.Int diff --git a/core/vm/jit_test.go b/core/vm/jit_test.go index a9ddd48a5..403c15a8d 100644 --- a/core/vm/jit_test.go +++ b/core/vm/jit_test.go @@ -175,11 +175,10 @@ func NewEnv(noJit, forceJit bool) *Env { return env } -func (self *Env) MarkCodeHash(common.Hash) {} -func (self *Env) RuleSet() RuleSet { return ruleSet{new(big.Int)} } -func (self *Env) Vm() Vm { return self.evm } -func (self *Env) Origin() common.Address { return common.Address{} } -func (self *Env) BlockNumber() *big.Int { return big.NewInt(0) } +func (self *Env) RuleSet() RuleSet { return ruleSet{new(big.Int)} } +func (self *Env) Vm() Vm { return self.evm } +func (self *Env) Origin() common.Address { return common.Address{} } +func (self *Env) BlockNumber() *big.Int { return big.NewInt(0) } func (self *Env) AddStructLog(log StructLog) { } func (self *Env) StructLogs() []StructLog { diff --git a/core/vm/runtime/env.go b/core/vm/runtime/env.go index c510be759..d8c98e545 100644 --- a/core/vm/runtime/env.go +++ b/core/vm/runtime/env.go @@ -27,10 +27,9 @@ import ( // Env is a basic runtime environment required for running the EVM. type Env struct { - ruleSet vm.RuleSet - depth int - state *state.StateDB - illegalHashes []common.Hash + ruleSet vm.RuleSet + depth int + state *state.StateDB origin common.Address coinbase common.Address @@ -50,15 +49,14 @@ type Env struct { // NewEnv returns a new vm.Environment func NewEnv(cfg *Config, state *state.StateDB) vm.Environment { env := &Env{ - ruleSet: cfg.RuleSet, - illegalHashes: cfg.illegalHashes, - state: state, - origin: cfg.Origin, - coinbase: cfg.Coinbase, - number: cfg.BlockNumber, - time: cfg.Time, - difficulty: cfg.Difficulty, - gasLimit: cfg.GasLimit, + ruleSet: cfg.RuleSet, + state: state, + origin: cfg.Origin, + coinbase: cfg.Coinbase, + number: cfg.BlockNumber, + time: cfg.Time, + difficulty: cfg.Difficulty, + gasLimit: cfg.GasLimit, } env.evm = vm.New(env, vm.Config{ Debug: cfg.Debug, @@ -81,8 +79,6 @@ func (self *Env) AddStructLog(log vm.StructLog) { self.logs = append(self.logs, log) } -func (self *Env) MarkCodeHash(hash common.Hash) {} - func (self *Env) RuleSet() vm.RuleSet { return self.ruleSet } func (self *Env) Vm() vm.Vm { return self.evm } func (self *Env) Origin() common.Address { return self.origin } diff --git a/core/vm/runtime/runtime.go b/core/vm/runtime/runtime.go index 9b75fcaad..309d508c3 100644 --- a/core/vm/runtime/runtime.go +++ b/core/vm/runtime/runtime.go @@ -35,18 +35,17 @@ func (ruleSet) IsHomestead(*big.Int) bool { return true } // Config is a basic type specifying certain configuration flags for running // the EVM. type Config struct { - RuleSet vm.RuleSet - Difficulty *big.Int - Origin common.Address - Coinbase common.Address - BlockNumber *big.Int - Time *big.Int - GasLimit *big.Int - GasPrice *big.Int - Value *big.Int - DisableJit bool // "disable" so it's enabled by default - Debug bool - illegalHashes []common.Hash + RuleSet vm.RuleSet + Difficulty *big.Int + Origin common.Address + Coinbase common.Address + BlockNumber *big.Int + Time *big.Int + GasLimit *big.Int + GasPrice *big.Int + Value *big.Int + DisableJit bool // "disable" so it's enabled by default + Debug bool State *state.StateDB GetHashFn func(n uint64) common.Hash diff --git a/core/vm_env.go b/core/vm_env.go index 1c1110280..599672382 100644 --- a/core/vm_env.go +++ b/core/vm_env.go @@ -25,8 +25,6 @@ import ( "github.com/ethereum/go-ethereum/core/vm" ) -var IllegalCodeHashes map[common.Hash]struct{} - // GetHashFn returns a function for which the VM env can query block hashes through // up to the limit defined by the Yellow Paper and uses the given block chain // to query for information. @@ -49,8 +47,6 @@ type VMEnv struct { depth int // Current execution depth msg Message // Message appliod - CodeHashes []common.Hash // code hashes collected during execution - header *types.Header // Header information chain *BlockChain // Blockchain handle logs []vm.StructLog // Logs for the custom structured logger @@ -76,8 +72,6 @@ func NewEnv(state *state.StateDB, chainConfig *ChainConfig, chain *BlockChain, m return env } -func (self *VMEnv) MarkCodeHash(hash common.Hash) { self.CodeHashes = append(self.CodeHashes, hash) } - func (self *VMEnv) RuleSet() vm.RuleSet { return self.chainConfig } func (self *VMEnv) Vm() vm.Vm { return self.evm } func (self *VMEnv) Origin() common.Address { f, _ := self.msg.From(); return f } -- cgit v1.2.3