Security reinforcement for Ethereum virtual machine

Highlights

• Detect dangerous transactions on blockchain in real time.

• Support for 4 common types of smart contract vulnerabilities.

• The reinforced EVM* has been implemented on two widely used EVMs, js-evm and FISCO-BCOS-evm.

Abstract

Smart contracts are more sensitive from a security perspective than other software due to several reasons. First, smart contracts are immutable thus cannot be easily patched once deployed. Second, smart contracts are directly tied to payments and can hold millions of dollars’ worth of digital currencies. Third, smart contracts are still a new practice thus do not have best coding practices and development lifecycles tailored for decentralized apps yet. Even though several testing and verification tools have been developed, smart contract vulnerabilities remain a clear and present danger. In this paper, we present an approach that is different from existing ones that attempt to eliminate vulnerabilities from smart contracts. Instead, we fortify Ethereum virtual machines (EVM) to stop dangerous transactions once vulnerabilities are detected in real-time. Since proving programs written in Turing-complete languages is undecidable, our approach complements current approaches by catching vulnerabilities and interrupts their executions during runtime. We have implemented our reinforcement on two widely used EVMs (js-evm and FISCO-BCOS-evm). The reinforced EVMs detects and interrupts all the vulnerabilities, 20% of them missed by testing tools, in 100 real smart contracts. Our approach is practical with less than 34% overhead. In fact, the reinforced FISCO-BCOS-evm has been integrated into the official release of FISCO-BCOS adopted by a large Chinese bank — WeBank.

Introduction

Ethereum is considered as the second large blockchain system in the world. Ethereum expands the blockchain concept with smart contracts. Smart contracts are the programs running on the Ethereum blockchain. In order to execute the smart contracts, Ethereum provides Ethereum Virtual Machine (EVM) to parse the source code of the contracts into an opcode sequence defined by Ethereum. Each node in Ethereum blockchain needs an EVM to execute the contracts properly and process the transactions. However, attacks on the smart contracts deployed on Ethereum platform are widespread and could cause a significant loss of money.

Many researchers attempted to improve the robustness of smart contracts with the customization of traditional testing techniques such as fuzzing and symbolic execution (melonproject, 2018, mythril-classic, 2018, trailofbits, 2018a). However, in real industry practice, we find that existing tools may miss some vulnerabilities hidden in the deep path of smart contracts. For example, we run ContractFuzzer on a contract with a known timestamp error for 2 h, but the bug was not detected. It is challenging for those techniques working on smart contract level to ensure security. The first is that testing before the deployment of smart contracts is not complete. It is not easy to explore all situations and paths, and the false positive and false negative cases would result in big potential issues. Another challenge is that the contract cannot be altered once after being deployed on Ethereum, and testing tools of smart contracts cannot protect the deployed contracts.

In this paper, instead of working on the vulnerability detection at the smart contract level, we propose EVM* to reinforce the underlying EVM implementations, which could hunt and interrupt the dangerous transactions in real time. The reinforced EVM* consists of three steps: monitoring strategy definition, opcode-structure maintenance and EVM instrumentation. Monitoring strategy definition provides the detail constraints and rules to decide whether there is a dangerous operation such as integer overflow during the execution of transactions. Opcode-structure maintenance is to maintain a structure to store the interesting opcodes and parameters related to the strategy definition. EVM instrumentation is to insert the monitoring strategy, interrupting mechanism and the opcode-structure operations in the original EVM source code. Then, the reinforced EVM* could monitor all the transactions and stop dangerous transactions with the predefined interrupt mechanism in real time.

We need to solve two main challenges during the EVM* design and implementation. The first is to define the strategies accurately because incorrect monitoring strategies would result in serious false positives and false negatives. The second is to ensure the monitoring with tolerable overhead because huge overhead or resource consumption would limit the practical usage of the EVM*. Furthermore, EVM* should be scalable to different EVM implementations and vulnerability types.

For evaluation, we implement EVM* on two widely used EVMs: js-evm (ethereumjs, 2018a) which is implemented in JavaScript, and FISCO-BCOS-evm (http://www.fisco-bcos.org. (Accessed 23 August 2019)) which is implemented in C++. We implement four common monitoring strategies (integer overflow, timestamp dependency, delegatedcall to an untrusted callee and send with insufficient gas) and throw an exception when encountered an unsafe action. A stack is implemented to store the strategy related opcodes as well as the operands. 100 real world smart contracts are collected with known bugs. Then we made a dangerous transaction on each contract on the original EVM and the reinforced EVM*. None of the dangerous transactions could be stopped by the original EVMs, while all the dangerous transactions on the reinforced EVM* could be interrupted successfully. For the time overhead, the reinforced EVM* with all the four monitoring strategies is slower than the original EVMs by 33.52%, and the reinforced EVM* with only one monitoring strategy ranges is slower for about 22.16%–28.98%.

Our main contributions lay on the following aspects:

• We proposed a framework of reinforcing EVMs to prevent dangerous transactions in real time, which is scalable for different EVM platforms such as cpp-evm and js-evm, and different types of bug such as integer overflow and timestamp dependency error.

• We implemented the reinforced EVM* on two widely used EVMs, js-evm and FISCO-BCOS-evm to protect the transactions from 4 common types of smart contract vulnerabilities. The reinforced FISCO-BCOS-evm has been integrated into the official release version 2.0 of FISCO-BCOS¹ in WeBank Company.

• We evaluated the effectiveness of the original EVMs and the reinforced EVM*. The reinforced EVM* could successfully stop all dangerous transactions from execution with a tolerable time overhead.