Annotary: A Concolic Execution System for Developing Secure Smart Contracts

TL;DR

Annotary is a concolic execution framework that helps developers identify vulnerabilities in Ethereum smart contracts by combining symbolic execution with concrete blockchain data, supporting inter-transactional analysis.

Contribution

It introduces a novel concolic execution system with developer-written annotations for analyzing smart contracts' inter-transactional control flows, surpassing existing formal verification methods.

Findings

Supports analysis of inter-contract control flows

Combines symbolic execution with real blockchain data

Reduces false positives in vulnerability detection

Abstract

Ethereum smart contracts are executable programs, deployed on a peer-to-peer network and executed in a consensus-based fashion. Their bytecode is public, immutable and once deployed to the blockchain, cannot be patched anymore. As smart contracts may hold Ether worth of several million dollars, they are attractive targets for attackers and indeed some contracts have successfully been exploited in the recent past, resulting in tremendous financial losses. The correctness of smart contracts is thus of utmost importance. While first approaches on formal verification exist, they demand users to be well-versed in formal methods which are alien to many developers and are only able to analyze individual contracts, without considering their execution environment, i.e., calls to external contracts, sequences of transaction, and values from the actual blockchain storage. In this paper, we present Annotary, a concolic execution framework to analyze smart contracts for vulnerabilities, supported by annotations which developers write directly in the Solidity source code. In contrast to existing work, Annotary supports analysis of inter-transactional, inter-contract control flows and combines symbolic execution of EVM bytecode with a resolution of concrete values from the public Ethereum blockchain. While the analysis of Annotary tends to weight precision higher than soundness, we analyze inter-transactional call chains to eliminate false positives from unreachable states that traditional symbolic execution would not be able to handle. We present the annotation and analysis concepts of Annotary, explain its implementation on top of the Laser symbolic virtual machine, and demonstrate its usage as a plugin for the Sublime Text editor.

Figures

Equations

$${\tau }_1:=\{{\Delta }_1,{\Phi }_1\}{\tau }_2:=\{{\Delta }_2,{\Phi }_2\}$$

$${\tau }_{12}:=\{{\Delta }_{12}:={\Delta }_1{\circ }_{\Delta }{\Delta }_2,{\Phi }_{12}:={\Phi }_1\cup ({\Delta }_1{\circ }_{\Phi }{\Phi }_2)\}$$

$$\Delta {\circ }_{\Phi }\Phi :=[substitute(\Delta ,\varphi ):\varphi \in \Phi ]$$

$${\Delta }_1{\circ }_{\Delta }{\Delta }_2:=[(k,substitute({\Delta }_1,\delta )):(k,\delta )\in {\Delta }_2]$$

Full text

1 Introduction

Smart contracts are small programs, executed by all verifying nodes of a blockchain as part of a consensus protocol. The idea of smart contracts is to distribute not only data but also computation to a set of potentially untrusted peers, in order to create distributed applications (”DApps”) that are not governed by a single party and operate correctly and reliably, as long as the majority of the blockchain network sticks to the protocol. In that sense, smart contracts implement the core business logic of DApps and are responsible for moving digital currency from one account (i.e., user) to another.

Ethereum, the most popular public implementation of the concept of smart contracts, is a permissionless public blockchain that uses the above concepts to create a digital currency called Ether, as well as a general-purpose distributed computing engine with a quasi-Turing complete execution model. [12]. Ether is publicly tradable similar to Bitcoin but also serves as the payment method for code execution of smart contracts in the Ethereum Virtual Machine (EVM), typically written in the programming language Solidity [13] and compiled into the EVM bytecode format which is then deployed to the peer-to-peer network.

In some applications, the amount of Ether controlled by a smart contract is enormous. From a security perspective, smart contract code can thus be regarded similar to code of smart card applets: the code implements simple functionality in a well-defined and constrained environment and is thus easy to verify, but errors in that code are not tolerable as extremely high values are at stake. At the same time, once deployed to the public, it is almost impossible to roll out security patches. Blockchains and DApps are created in a rapidly evolving industry where time-to-market is crucial, and smart contract developers rarely have a background in writing highly critical code or experience with formal verification methods. Various severe incidents have happened in the past, where vulnerabilities in smart contracts allowed to lock in or withdraw significant amounts of Ether from popular DApps. To name only a few, this includes the PoWHCoin bug, the first Parity bug (153,037 ETH stolen) [3], the second Parity bug (513,774.16 ETH frozen) [5], and the DAO hack (3.6 mio. ETH stolen) [1] which finally lead to a hard fork of the Ethereum blockchain. These incidents suggest that writing secure smart contracts is challenging and effectively supporting developers in avoiding vulnerabilities is a necessity. Rigid formal verification methods have been proposed in the past [2] but later dismissed, as they put too high demands on developers who are no experts in this field. Simple static analysis approaches, on the other hand, help to avoid simple programming errors but are far from being precise enough to discover subtle flaws – especially those manifesting in the interaction between multiple contracts.

In this paper, we introduce Annotary, a concolic execution tool that supports Solidity developers in writing error-free smart contracts. In contrast to other tools which focus on searching predefined vulnerability patterns, we take a developer-centric perspective and allow developers to express their expectations in the form of annotations directly in the Solidity code. Annotary then conducts a concolic execution analysis of the compiled EVM bytecode against these annotations and informs the developer about potential violations – currently in the form of a plugin for the Sublime editor. We advance the state of the art in EVM analysis by including interactions between contracts and along chains of transactions in the analysis and make the following contributions

extend concolic analysis of EVM bytecode to properly span contract interactions and sequences of transactions. 2. 2.

a backward-compatible extension of the Solidity language by annotations which allows developers to state verifiable properties 3. 3.

a proof-of-concept implementation of Annotary, including a Sublime Text plugin

2 Background

Although at a syntactical level, Solidity resembles C or JavaScript, its execution model has some peculiarities that require further discussion. Furthermore, we will provide some background on Mythril, a vulnerability scanning tool for Ethereum smart contracts, that we significantly extended in the process of developing Annotary.

2.1 Solidity and Smart Contracts

Solidity is a high-level language for implementing smart contracts and targets the Ethereum Virtual Machine (EVM) platform. It is statically typed, supports multiple inheritance, libraries, complex user-defined types, contracts as members, overloading and overwriting, abstraction and interfaces, as well as encapsulation through visibility modifiers. Solidity’s contract-orientation appears similar to object-oriented languages, using the contract keyword instead of class. However, in contrast, to truly object-oriented languages, such type definitions do not end up in the actual bytecode which consequently only includes instantiations of contracts and their respective functions [13]. A special contract-creation transaction is used to invoke the ”constructor” and as a result, the contract is instantiated and assigned a public address which only holds the code that can be called by transactions. It is also important to note that contracts created from the same code basis do not share any data or (static) functions.

1 illustrates some typical concepts of the Solidity language, including inheritance and two different ways to declare constructors. The constructor in   LABEL:code:l1

is declared by naming the function equal to its contract (analog to languages like Java), while  LABEL:code:l3

uses the newer constructor keyword (analog to JavaScript, albeit Solidity merely treats constructor as a function modifier), which became mandatory in version 5.0 [7] of Solidity to avoid vulnerabilities related to simply misspelling function names. The example also shows two patterns which are common in smart contracts: first, the constructor keeps track of the owner who originally deployed the contract by assigning the associated 20-byte address  LABEL:code:l2

passed to the constructor to the owner field. This allows the contract to later distinguish between calls that are made by its original owner or by anyone else. Second, the contracts defines a nameless default function  LABEL:code:l4

that is called when callers invoke the contract without referring to a specific function. In this case, the require-statement will roll back the transaction if the sender attempts to send any Ether (msg.value) to a non-existing function. To address a specific function in a transaction, it must include the function identifier, which is computed as the first four most significant bytes of the keccak256 hash of the function signature.

Entities and Interactions

Ethereum is a distributed system building a singleton computer with accounts as entities and transactions referring to accounts as the smallest units of computation. Accounts are identified by a 160-bit address, have a balance of Ether, a transaction counter, and two possibly empty fields: the associated bytecode and storage state. Wallets are contracts with empty bytecode and their 160-bit address is the hash of their public key. The holder of the private key signs transactions proving its origin to be the Wallet. Transactions to these accounts can only transfer Ether. Accounts with associated bytecode are contract accounts and receive their address in a deterministic process when a contract creation transaction is sent to the network. The construction-bytecode is run, and the resulting state of the contract is some possibly non-empty storage state and the runtime-bytecode.

Transactions are signed data packets that represent a message to an account by specifying its address in the to-field or a contract-creation transaction if the content is 0. Messages can be the result of a transaction or of subsequent deterministic calls between contracts when bytecode is executed. They are unsigned blocks of data sent from one account to another still associated with the verified initial sender of the transaction. If an account with non-empty bytecode receives a message, an instance of the EVM is started with the target account’s bytecode and the message data as input. Returned data is passed to the calling EVM context or returned as transaction result.

2.2 EVM and Bytecode

EVM has a simple stack-based architecture with a word size of 256 bit that allows to directly map keccak-256 hashes to addresses. A predefined finite resource called gas must be assigned to each transaction and serves as the unit for computational effort that is consumed by each EVM instruction. It thus helps to prevent Denial-of-Service (DoS) attacks by stopping the execution when it is depleted, making the EVM a quasi-Turing-complete machine that has a Turing-complete instruction set but can only execute a limited number of statements [24]. The simplicity of the EVM bytecode with its 70 main instructions made the EVM a popular target for formal verification projects [15, 22, 10]. During execution the EVM maintains three main types of memory that are also relevant for the analysis by Annotary:

The world state ${\bm{\sigma}}$ is a mapping from 160-bit addresses ${\bm{a}}$ to account states and is kept in a Merkle Patricia tree that represents the result of executing all transactions saved on the Ethereum blockchain. A mapped account state ${\bm{\sigma[a]}}$ contains the balance ${\bm{\sigma[a]_{b}}}$ in Wei, the smallest sub-unit of Ether ($10^{18}$ Wei = 1 Ether), the storage ${\bm{\sigma[a]_{s}}}$ as mapping from 256-bit integer values to 256-bit integer values ${\bm{\sigma[a]_{s}}:2^{256}\rightarrow 2^{256}}$, and the immutable runtime bytecode ${\bm{\sigma[a]_{c}}}$ of an account that is executed in the case of message receipt.

The execution environment ${\bm{I}}$ contains data that is fixed during message processing, including the address of the current message recipient ${\bm{I_{a}}}$ whose code is executed, and the sender of the message ${\bm{I_{s}}}$. ${\bm{I_{o}}}$ is the account associated with the original transaction and may differ from ${\bm{I_{s}}}$ for inter-contract messages. ${\bm{I_{d}}}$ contains the input data for the current execution, such as function parameters. ${\bm{I_{v}}}$ contains the value of Ether in Wei transfered from the sender ${\bm{I_{s}}}$ to the recipient ${\bm{I_{a}}}$. ${\bm{I_{b}}}$ contains the runtime bytecode of ${\bm{I_{a}}}$ that is executed and ${\bm{I_{H}}}$ stores the header of the block that the current transaction will be mined in.

The machine state ${\bm{\mu}}$ contains the variable and volatile part of the computation held only during message processing. These include the volatile operand LIFO stack ${\bm{\mu_{s}}}$ with 256-bit words and a byte-addressable heap memory ${\bm{\mu_{m}}}$ used for more complicated computation or larger chunks of data. It further holds the program counter ${\bm{\mu_{pc}}}$ and the output byte-array ${\bm{\mu_{o}}}$ of the execution. Changes of the execution are not persisted if not send or returned to a different account or stored in ${\bm{\sigma[a]}}$.

2.3 Mythril and the Laser-SVM

Mythril [20] is an open-source security analysis tool for Ethereum smart contracts and serves as the foundation for Annotary111As Mythril is under active development, this paper refers to the commit hash github.com/ConsenSys/mythril-classic/commit/b5afa9ff1aa2b5dc8863d29aa9e0a24b34eb4747 of the project

It uses Laser-SVM, an internal symbolic virtual machine, to explore smart contract bytecode in a depth-first search fashion over the control flow graph (CFG). For this, it operates on a representation of ${\bm{\sigma}}$, ${\bm{I}}$ and ${\bm{\mu}}$. Values that are unknown during execution are represented as symbolic variables, and the explored execution paths are transformed into path conditions, i.e., constraint systems over the symbolic variables along the respective execution path. Mythril runs vulnerability detection modules that inspect the explored executions states for known vulnerability patterns and attempts to compute concrete input values leading to the execution of the vulnerability by solving the respective constraint system using the Z3 SMT solver [19]. As the EVM uses 256-bit operands for computation, Mythril uses a bit-vector algebra at a fixed size of 256 bits to model arithmetic operations and boolean algebra. While Mythril and especially its Laser-SVM provide a good basis of concolic/symbolic execution for EVM bytecode, Mythril’s goal is not to allow analysis of specifiable properties. Mythril lacks the following capabilities which Annotary aims to provide:

• •

The ability to let developers specify invariants and assertions in the contract and the ability to verify them before the potentially vulnerable contract is irrevocably deployed.

• •

A model of EVM instructions and execution semantics for inter-contract- and inter-transactional control flows.

• •

Reachability analysis of transaction sequences to reduce false positives.

• •

Symbolic execution of contract constructors with parameters.

3 Annotation Driven Concolic Analysis

Rather than exploitation, Annotary aims at secure development while expanding the analysis scope to inter-contract and inter-transactional analyses. We begin this section by outlining the overall system and then detailing the main aspects of the analysis.

Figure 1 shows how Annotary’s editor plugin passes source and configuration files to the analysis component and receives found annotation violations for visualization.

3.1 Annotations

Annotary specifies a set of annotations which developers can use to express invariants and restrictions directly in the Solidity source code. These annotations will then be translated into constraints or injected as asserts and analyzed to become part of the constraint system for an execution path. As annotations may include expressions, as well as references to Solidity functions and members, they require a separate compilation pass in addition to compilation of the actual source code. This is done by the annotation processor which takes annotations as input and translates them into EVM instructions by rewriting the original contract code. The purpose of the so added instructions is only to create additional constraints. To not alter the semantics such as state or control flow of the actual contract the execution of inserted code is isolated from the rest. When the symbolic execution reaches a state that violates any constraint derived from an annotation, the contract is considered to violate the developer’s expectations, and the violation is reported to the developer. Annotary implements three types of annotations:

Inline checks: The annotation "@check("BoolExpr")" and its negation

"@never("BoolExpr")" specify properties inside a contract function that are checks whether or not the specified condition holds. The condition can hold any boolean expression valid in solidity including calls to other functions and contracts. 2. 2.

Contract invariants: The annotation "@invariant("BoolExpr")" defines a contract wide condition that has to hold whenever a transaction persists its state. 3. 3.

Set restrictions: restricts writing to a member variable from outside of explicitly allowed functions. A state at a SSTORE instruction is reported a violation if the SSTORE writes to the protected variable and the function is not explicitly allowed to. Users can specify these restrictions with the following annotation:

"@set_restricted("["var="{[ContractName "."] MemberName[","]} ";"]} ["func="]{"constructor"|FunctionName|FunctionSignature}")"

3.2 Modeling Transaction Execution

Depending on the type of data, Annotary uses different strategies to treat memory locations either as concrete or as symbolic values. Concrete values will be initialized according to the EVM’s actual behavior, i.e., storage on contract creation will be initialized by 0. Symbolic values refer to variables of the SMT constraint system which refer to specific memory locations. For instance, we write $\sigma[I_{a}]_{s}[key]\rightarrow BitVecRef(storage[key],256)$ to denote the allocation of a variable key in storage. In general, when writing data to some memory location, Annotary supports both concrete and symbolic values and propagates data of the respective type to the memory location. When data is read from a previously unused location, however, it depends on the data type whether Annotary will treat it as symbolic or concrete:

Call data is modeled symbolically to represent all possible user interactions with the contract. Memory is treated concretely and reinitialized with the default value 0 for constructor and transaction execution. The creation code itself is known, but the appended initialization parameters are unknown at analysis time and thus handled symbolically. Reads after the end of the known instructions default to return symbolic variables.

Storage is set to the concrete type when the constructor is executed. On this first transaction, the content of storage is known and defaults to returning 0 when reading from unwritten locations.

Then, storage is reset to be empty and treated symbolically henceforth to represent the most generic state space and account for all unknown transactions that might have happened between construction and invocation of the smart contract.

3.3 Inter-contract Analysis

Annotary can correctly handle dependencies between contracts, including those which manifest only at Solidity but not at bytecode level.

Contract inheritance: is the only relation that is not directly visible in bytecode and requires Annotary to pre- and post-processes Solidity code. It uses the C3-linearization of the inheritance hierarchy to identify transaction implementations defined by a parent contract that are callable once the child contract is deployed. Asserts referencing member variables of a child contract cannot be directly injected into the transaction function of the parent contract, as the member variable is not in the parent’s scope. To solve this, Annotary generates a proxy function with the same signature in the child contract that delegates the call through the super keyword and injects the assert.

Nested contract creation: Contracts can create other contracts by piggybacking the necessary constructor bytecode in their runtime bytecode. Annotary spawns a new symbolic execution with the creation bytecode extracted from the current transaction execution.

Inter-contract interactions: happen when the analyzed contract performs a message call or executes foreign contract code on their storage. Symbolically executing these interactions allows to resolve potentially returned values and to understand changes on the analyzed contracts state. Annotary implements symbolic execution for several EVM instructions for inter-contract interaction, lacking by Mythril, including CREATE, STATICCALL, RETURNDATACOPY, RETURNDATASIZE, and EXTCODECOPY. All instructions that trigger inter-contract interactions are executed with the appropriate concrete or symbolic persisting data type:

CALLCODE and DELEGATECALL execute external contract code referenced by the address of the external contract in the context of the current contract and can, therefore, change the contracts persistent storage. If address and code can be resolved, symbolic execution can account for these calls effects. If they cannot be resolved, storage has to be reset to be empty and symbolic, and the variables in the constraints are renamed to avoid collisions.

CALL and STATICCALL are executed with empty symbolic storage for the first interaction and with the initialized symbolic storage on further interactions.

CREATE deploys a new contract and executes the contract creation with empty concrete storage that is used for further interactions with the contract in the same transaction. In other transactions executions storage will be considered empty and symbolic.

3.4 Inter-transactional Analysis

Annotary implements inter-transactional reachability analysis to eliminate false positive violations that are not reachable considering the possible set of contract transactions.

3.4.1 Extracting Transaction Traces

Annotary uses transaction traces $\tau=\{\Delta,\Phi\}$ for inter-transactional analysis, information of a contract execution that persists after the execution is finished:

• •

$\mathbf{\Delta}$ is a mapping of symbolic state variables $k$ in $\sigma[I_{a}]$, e.g., storage slots or balance, of the currently analyzed contract to SMT bit vector expressions $\delta$, representing the change that a transaction performs on the state.

• •

The trace constraints $\mathbf{\Phi}$ are a set of conditions that have to hold such that the transaction represented by $\tau$ can be executed on the contract. $\mathbf{\Phi}$ is a subset of the path constraints. Path constraints with no reference to the previous state, e.g., only to input data, are not included in $\mathbf{\Phi}$ and do not lower the accuracy of reachability analysis.

Traces should represent state changing transactions that can appear amid a transaction sequence. The global states at the persisting instructions STOP and RETURN, are taken into consideration, while states at SELFDESTRUCT cannot be followed by further transactions and are therefore ignored. States with unchanged persisted values, e.g., in storage and balance, are filtered out due to irrelevance for the sequence and states with unsatisfiable path constraints due to inapplicability. $\Delta$ and $\Phi$ are extracted from global states that represent the unmodified contract execution, reducing constraints by all that are not relevant in an inter-transactional analysis.

Annotary differentiates between constructor transaction traces ($\bm{\tau_{c}}$) and message transaction traces ($\bm{\tau_{m}}$) and brings states that may violate an annotation into a transaction trace representation ($\bm{\tau_{v}}$) to allow reachability analysis.

3.4.2 Chain Transaction Traces

Annotary combines traces through expression substitution to explore the possible persisted states of a contract instead of iterative concolic execution. $\tau_{12}:=\tau_{1}\circ\tau_{2}$ represents the symbolic trace left onto the contract state when $\tau_{1}$ is executed before $\tau_{2}$. Definition 1 shows how traces are combined. The changes to the contract state $\Delta_{1}$ that trace $\tau_{1}$ applied exist at the beginning of trace $\tau_{2}$. Therefore the changes $\Delta_{1}$ have to be applied to the expressions used in $\Delta_{2}$ and $\Phi_{2}$.

[TABLE]

[TABLE]

$\circ_{\Phi}$ in Definition 2 and $\circ_{\Delta}$ in Definition 3 are necessary operations to apply the storage changes $\Delta_{1}$ to $\tau_{2}$. $\Phi$ is a list and $\Delta$ is a mapping of expressions. The pairs $(k^{\prime},\delta^{\prime})$ in the mapping $\Delta$ can be used together with the SMT-solvers substitute function to replace appearance of a value $k^{\prime}$ in an expression e with $\delta^{\prime}$.

[TABLE]

[TABLE]

We further define two properties for traces, spanning one or more transactions: A trace $\tau$ is valid if its constraints are satisfiable. An invalid trace means that the constraints are not satisfiable and thus this sequence of instructions and calls among transactions is not executable at runtime. In the following, we denote satisfiability of a trace as $\textsf{sat}(\tau)$. A trace can further be state independent if its constraints do not contain any symbolic variables k referencing the previous contract state. State independence means that execution of that trace does not depend on the prior execution of any other contracts and is denoted by $\textsf{svar}(\tau)=\emptyset$.

3.4.3 Confidence Levels

By combining the properties of validity and state independence, Annotary expresses the confidence with which found violations will exist at runtime. Annotary supports the following confidence levels, from most to least confident:

Single transaction violation: For the intra-transactionally verified violating trace $\tau_{v}$, $\textsf{sat}(\tau_{v})\land\textsf{svar}(\tau_{v})=\emptyset$ holds. In this case, the transaction violates the annotation. 2. 2.

Chained transaction violation: For a valid and state independent trace $\tau_{m^{*}v}$ of optionaly many applications222shorthand notation: $\tau_{a}\circ\tau_{b}:=\tau_{ab}$, application of $d$ arbitrary set members $\tau_{m^{d}}:=\tau_{m_{1}}\circ...\circ\tau_{m_{d}}$ of transactions from $\tau_{m}$ and finally $\tau_{v}$ (i.e., $\textsf{sat}(\tau_{m^{*}v})\land\textsf{svar}(\tau_{m^{*}v})=\emptyset$ holds). In this case, the annotation is violated, independent from which contract state the call is made. 3. 3.

Constructed violation: A sequence of traces starting from the constructor was found that can trigger the annotation violation and is $\textsf{sat}(\tau_{cm^{*}v})\land\textsf{svar}(\tau_{cm^{*}v})=\emptyset$. The attacker requires to be the contract creator or find a contract in the required state. 4. 4.

Unconfirmed violation: The chaining depth $d$ was reached and there is at least one $\tau_{m^{d}v}$ that is $\textsf{sat}(\tau_{m^{d}v})\land\textsf{svar}(\tau_{m^{d}v})\neq\emptyset$. 5. 5.

Violation avoiding context: A point in the analysis was reached where the possibilities of chaining transactions to reach the violating state was exhausted. This means that although $\textsf{sat}(\tau_{v})\land\textsf{svar}(\tau_{v})\neq\emptyset$ it is also such that $\exists c\in\mathbb{N}:c<=d:(\nexists\tau_{m^{c}v}\in T:\textsf{sat}(\tau_{m^{c}v}))\land\forall e\in\mathbb{N}:e<=c:\nexists\tau_{m^{e}v}\in T:\textsf{sat}(\tau_{m^{e}v})\land\textsf{svar}(m^{e}v)=\emptyset$. 6. 6.

Unsatisfiable violation: The violating transaction $\tau_{v}$ is not satisfiable. This means $!\textsf{sat}(execution\_constraints_{\tau_{v}})$.

3.4.4 Chaining Strategy

To check the validity of a found violation two high level strategies can be used to explore transaction traces:

Forward: Starting from the set of constructor and transaction traces $T_{c}\cup T_{m}$, the current trace chains are applied to $T_{v}\cup T_{m}$, and the new trace chain is checked for satisfiability. If the chain is satisfiable, the violation is confirmed.

Backward: Starting from the violating traces $\tau_{v}\in T_{v}$, the set of contract traces $T_{c}\cup T_{m}$ are applied to the set of remaining transaction chains. If an explored trace chain is valid and state independent, the violation is confirmed. If the form of the sequence is $\tau_{cm^{*}v}$ the exploration attempts to find a more threatening sequence $\tau_{m^{*}v}$.

Annotary uses this strategy depicted in Figure 2 as it allows to differentiate between violations with confidence level unconfirmed violation and violation avoiding context. The size of initial traces is smaller if $|T_{c}\cup T_{m}|>|Tv|$. Trace chaining scales better if $|T_{c}\cup T_{m}|<|T_{v}\cup T_{m}|\iff|T_{c}|<|T_{v}|$.

4 Implementing Annotary

This section elaborates on the implementation of the Annotary, i.e., a Sublime Text plugin and the inter-contract concolic analysis on top Mythrils Laser-SVM.

4.1 Preprocessing of Solidity Contracts

In a first preprocessing step, Annotary parses Solidity source files and extracts the annotations stating the conditions that will be analyzed. The input files are then parsed with the solidity compiler solc to gain the construction (bin) and runtime binaries (bin-runtime) of the contracts, the source code mappings (srcmap), that link the symbolically executed instructions to the code segments they were compiled from, the contracts application binary interface (ABI), which describes the transactions that can be executed and the expected input parameters, and finally the contract’s abstract syntax tree (AST) to identify transaction endpoints, retrieve inheritance structures, functions and member variables.

Annotary adds a rewriting pass to the compilation process that converts @check and @invariant annotations into corresponding sets of assert statements, as in Appendix A.2. Furthermore, Annotary modifies the Laser-SVM to isolate the execution of rewritten code from affecting the rest of the symbolic execution. We extended the Laser-SVM by a state processor that keeps track of instructions, result of the rewrite pass, excluding the resulting states from the set of unmodified contract states.

4.2 Concolic Execution

Annotary builds upon the Laser-SVM to extend inter-contract and adds inter-transactional analysis. We now guide the reader through the most significant building blocks that Annotary adds to Laser-SVM.

4.2.1 Symbolic Handling of Inter-contract Calls

Annotary extends Laser-SVM by adding handlers for instructions that were not supported, in order to close the semantic gap between Laser-SVM and EVM. The CREATE instruction is implemented by executing a contract creation transaction with the nested contract code extracted from the current contract. The prior transaction execution is resumed with the newly created contract in $\sigma$. Support for the STATICCALL instruction is added, analog to the CALL instruction with msg.value set to 0, as no funds are transferred, and a flag that prevents SSTORE-instruction in nested calls to write persistent storage. RETURNDATASIZE and RETURNDATACOPY are implemented by extracting size and data from the global state and copying them to stack and memory, respectively. If Annotary successfully resolves the concrete address that is given to EXTCODECOPY, the retrieved external code is copied to memory and treated concretely.

4.2.2 Pre-, and Post-processing and Filtering of States

Annotary modifies how the Laser-SVM processes instructions in its worklist to handle instructions differently that have been added to the unmodified contract code.

For instance, the ASSERT_FAIL instruction, would immediately terminate the execution when a given condition is not fulfilled. If that instruction has been inserted into the bytecode as a consequence of an @check annotation, however, we need a different semantic, as we want to detect the violation of the annotation, but not necessarily terminate the symbolic execution at that state. We thus extend Laser-SVM by state labels that mark individual states in the explored symbolic state space as Violating and/or Ignore to indicate that this state was the result of code modification to identify violations and shall be saved and/or isolated from the set of states representing the execution of the unmodified code.

4.3 Violation Identification and Classification

After the concolic execution, Annotary has access to the state space of the unmodified contract and a set of states violating the @check or @invariant annotations. We can map these directly to warnings that will be displayed to the developer at the corresponding line of code. The @set_restricted annotation limits write operations to a member variable to a set of valid functions and thus needs to search for violating states at SSTORE instructions. The writing function is identified over the instruction association to code and the saved path constraint that stems from the selected function identifier. The written Solidity member is identified through the storage index according to the computed outline in storage, which requires Annotary to keep track of relevant keccak256 results, depicted in Appendix A.3. Annotary searches through the state space for a path that starts at a violating location and ends in a state at a STOP or RETURN that would effectively persist the violating transaction to storage.

4.3.1 Chaining Transactions

Annotary chains transactions by merging selected states from the symbolic state space of one transaction into the state space of the previous transaction. The selection includes only relevant states, i.e. only those which have inter-transactional effects (e.g., write to storage).

When creating execution traces of transaction sequences, Annotary maintains meta-data that is assigned to the sequence and presents users more qualified information such as the transaction depth and the sequence of contract functions, as well as data to optimize the trace chaining operation, such as the set of symbolic state variables that references prior contract states and the set of transaction variables. Both sets allow to keep track of variables that have to be substituted or renamed when combining transactions and allows for an efficient implementation using the Z3 expression substitution functionality. However, chaining transactions will lead to an explosion of possible chains and thus explored states, limiting the depth of transaction sequences that can be analyzed. We illustrate this effect with real-world contracts in Section 5.

Annotary analyzes transactions preceeding a violating trace for two purposes. A valid chain confirms the inter-transactional validity of the violation and the resulting confidence level gives a more nuanced judgment of the violation. Algorithm 4 in Subsection A.3 shows how the sequence of preceeding transactions with the highest confidence level that leads to a given violation is found. When the violating transaction sequence contains no symbolic state variables in the constraint expressions, a state independent chain of length one is found, it is assigned the confidence level single transaction violation. At every iteration step, all traces in $\tau_{c}\cup\tau_{m}$ are applied to the violating sequences of depth $n-1$, which in the beginning is only the violating trace. Traces are only applied to a sequence if they overwrite a symbolic state variable and the set of constraints are checked for satisfiability before they are added to the set of violating sequences of length $n$. If a transaction sequence ends in a constructor trace $\tau_{c}$, the chain is saved with the confidence level Constructed violation but the search for a more severe violating sequence is continued. If the trace is from the set $\tau_{m}$ and chained trace is state independent, the search is terminated with a sequence of confidence Chained transaction violation. If the set of new sequences is empty because all trace applications resulted in sequences with unsatisfiable constraints, the initial violation gets the confidence level Violation avoiding context. If the maximal depth is reached the violating trace is of confidence level Unconfirmed violation. After all violations are categorized, the annotation’s violation confidence level is set to the highest level of the found sequences. Finally, all annotations with their violations are returned in JSON-format to the Sublime Text plugin.

4.4 Annotary Plugin

The Annotary plugin bridges the gap to concolic execution from within the Sublime Text editor. Annotations are written inside of Solidity files, and a context menu allows to run the search for violations. Annotations and violating code pieces are visualized inside of the documents, e.g., in Figure 3 in Subsection A.1. Hovering over them shows the confidence level, the violating transactions, and informative description. A config allows disabling trace chaining, set the depth of chained traces and followed jumps during concolic execution.

5 Discussion

We evaluated Annotary with respect to its effectiveness and efficiency. First, we assessed how Annotary performs with vulnerable contracts and if it would detect all vulnerabilities as expected. We thus created a sample set of 11 small contracts with known programming mistakes that have led to severe vulnerabilities in the past and added annotations that would have made Annotary detect the flaw. Among others, this set includes the following mistakes: one of the Parity bugs [5] allowed execution of an initialization function because of the unset member variable initialized. By adding an @invariant(initialized==true) annotation, Annotary was able to spot this vulnerability. This mistake is especially hard to spot for humans if non-obvious call paths over library functions allow the execution of the initialization function [3] or if typos such as state =+ 1 (which evaluates to state = 1) instead of state += 1 are present. A further included mistake is to erroneously expose functions that allow writing to some member variable by incorrectly setting (or omitting) one of Solidity’s four visibility modifiers for functions. Annotary catches this error, if the member variable is annotated with @set_restricted. Another, especially subtle mistake is writing to uninitialized structs. Structs can be persisted in either memory or storage and if declared in ”C style” and not marked otherwise, default to storage. If fields of a struct are written without prior initialization, the write operation will overwrite the first storage slots, which can lead to disastrous consequences. Consider this snippet, which overwrites the owner address by calling doSth().

⬇

1contract test{

2 struct MyStruct { uint myField; }

3 address owner; // Keeps track of privileged owner

4

5 function doSth() {

6 MyStruct s;

7 s.myField = uint(msg.sender); // Overwrites owner

8 } }

Annotary detects this vulnerability, if owner is annotated with @set_restricted (cf. Figure 3), even taking delegated calls into account.Annotary detects all programming mistakes in the ”small’ sample set. Table 2 lists the mistakes and used annotation types.

In a second step, we were interested in the performance of Annotary with real-world contracts and created a second sample set of 24 large contracts with the highest balance of Ether and available source code in the public Ethereum network. These contracts were not annotated and are not known to contain vulnerabilities, it is therefore not possible to create data underpinning the soundness and completeness of Annotary. Nevertheless, we evaluated the coverage of the symbolic execution, the runtime, and scalability with respect to the depth of chained execution traces to give an impression on Annotary’s runtime. As can be seen from Table 1, the coverage of the ”large” sample set is 80%, while the coverage of the small set is 88%. The average runtime for the ”small” set is 4 seconds, which we consider well-suited for IDE integration, especially when considering that no performance optimizations have been done so far. For the real-world contracts from the ”large” sets, the average runtime is with 700 seconds significantly higher due to larger code sizes. Columns d$<$n$>$ in Table 1 illustrate how increasing the depth of the analyzed call chains adds significant runtime overhead. A feasible mode of operation might thus be to configure the depth of analysis in the IDE to be lower and to run a full analysis in a CI server.

6 Related Work

Symbolic execution approaches with the pioneer Oyente [18] by Luu et al., the extension Osiris [23] by Torres et al., and Mythril [20] by Bernhard Mueller et al. use the results of symbolic execution and SMT-solving to find known vulnerabilities in an intra-transactional context. MAIAN [21] by Nikolic et al. extends this approach to an inter-transactional context and finds vulnerability patterns defined over multiple transactions. Annotary builds upon Mythril’s Laser-SVM and extends it to support inter-contract analysis. Our work further differs from the aforementioned tools in that it supports inter-transactional executions chains. To the best of our knowledge, Teether [17] by Krupp and Rossow is the only publication that also considers transaction traces. However, Teether does not allow customizable checking of properties but rather searches already deployed contract for a single vulnerability pattern. Our contribution is thus the first customizable development framework for smart contract developers, supporting inter-contract and inter-transactional analyses. Further work related to our is Zeus [16] by Kalra et al., which translates Solidity into LLVM and performs model checking against policies. Vandal [11] by Brent et al. converts EVM bytecode to abstract semantic logic relations and analyzes logic constraints over them. Formal verification in the form of Why3 [14] was already integrated into the Solidity online IDE Remix, requiring developers to create semi-assisted proofs, but the support was later removed [6]. Other attempts include the formalization of contracts and EVM in F* [10] by Bargavan et al. and in the formal verification framework Lem [4], that do not precisely capture inter-contract analysis and do not support inter-transactional analysis. Ahrendt et al. propose to translate Solidity into Java to make use of KeY, a well-approved theorem proving framework for Java programs [9]. Hildenbrandt et al. introduced the KEVM [15], an executable formal specification of the EVM in the $\mathbb{K}$ framework which provides inter-contract and inter-transactional provability of claims by formulating all-path reachability statements. All these approaches require users to formulate desired properties in a formal language understood by the verifier, e.g., $\mathbb{K}$’s XML-style language or Why3’s WhyML.

7 Conclusions

The field of secure development of smart contracts is still in its infancy and some of its challenges are fundamentally different from traditional software development due to the distributed computation model and the immutability of code. We contribute Annotary to this field, an approach that strikes a balance between rigid but hard-to-use formal methods and static source code analyzers which have no knowledge of intent, thus producing too many false positives. Our three main conclusions from this work are that first, annotations are a feasible way for developers to express their expectations and check their contracts for correctness in a language and environment they are comfortable with. Earlier work on integrating formal verification methods into Solidity has been dismissed for that reason, while the SMT-checking based approach that also Annotary adopts seems to be well received by the community (cf. [20, 8]). Second, inter-contract and inter-transactional analysis are required to make sound statements about the security of a contract. Analysis of a single contract captures only a fraction of an actual Ethereum transaction and will not be able to create sound statements about safety and security guarantees. Third, the use of concrete values helps to increase precision and at the same time limit the complexity of the analysis. In contrast to traditional programs, where the specific execution environment is not known at the time of analysis, we can resolve concrete addresses referring to the Ethereum network and retrieve actual values from there.

The different confidence levels of Annotary allow for a more nuanced interpretation of findings by the developer, as opposed to traditional source code analyzers which rank all findings equally relevant. As part of our prototype evaluation, we have shown how Annotary detects common programming pitfalls and is able to detect cross-transaction vulnerabilities. The runtime analysis suggests its applicability in an IDE for smaller contracts and acceptable runtimes for larger contracts when integrated into continuous integration (CI) processes.

Acknowledgements

This work was partially funded by the Bavarian Ministry of Economics as part of the initiative Bayern Digital as well as the Fraunhofer Cluster of Excellence ”Cognitive Internet Technologies”.

Appendix A Appendix

A.1 Annotary IDE Plugin

A.2 Code Rewritings

Inline Checks

at annotation position: @check(condition) $\longrightarrow$ assert(condition);

Asserting Invariants

- at empty block end: $\emptyset\longrightarrow$ assert(condition);.

- before empty return statement: return; $\longrightarrow$ assert(condition); return;.

- before return with value: return (exp1, ...); $\longrightarrow$ var (v_<nonce1>,...) = (exp1, ...; assert(condition); return (v_<nonce1>, ...);.

Proxy Asserts to inherited Functions that

- do not return values: $\emptyset\longrightarrow$ function f_name(param1, ...)... { super.f_name(param1, ...); assert(condition);}

- do return values: $\emptyset\longrightarrow$ function f_name(param1, ...)...{

var (v_<nonce1>,...) = super.f_name(param1, ...);

assert(condition); return (v_<nonce1>, ...); }

A.3 Algorithms