Solidity Optimizer and ABIEncoderV2 Bug Announcement
By means of the Ethereum bug bounty program, we obtained a report a couple of flaw inside the new experimental ABI encoder (known as ABIEncoderV2). Upon investigation, it was discovered that the part suffers from just a few completely different variations of the identical sort. The primary a part of this announcement explains this bug intimately. The brand new ABI encoder continues to be marked as experimental, however we however suppose that this deserves a outstanding announcement since it’s already used on mainnet.
Moreover, two low-impact bugs within the optimizer have been recognized over the previous two weeks, certainly one of which was fastened with Solidity v0.5.6. Each had been launched with model 0.5.5. See the second a part of this announcement for particulars.
The 0.5.7 release comprises the fixes to all bugs defined on this weblog publish.
All of the bugs talked about right here ought to be simply seen in checks that contact the related code paths, no less than when run with all mixtures of zero and nonzero values.
Credit to Melonport staff (Travis Jacobs & Jenna Zenk) and the Melon Council (Nick Munoz-McDonald, Martin Lundfall, Matt di Ferrante & Adam Kolar), who reported this by way of the Ethereum bug bounty program!
Who ought to be involved
In case you have deployed contracts which use the experimental ABI encoder V2, then these is likely to be affected. Because of this solely contracts which use the next directive inside the supply code could be affected:
pragma experimental ABIEncoderV2;
Moreover, there are a selection of necessities for the bug to set off. See technical particulars additional beneath for extra data.
So far as we will inform, there are about 2500 contracts stay on mainnet that use the experimental ABIEncoderV2. It’s not clear what number of of them include the bug.
Methods to examine if contract is susceptible
The bug solely manifests itself when the entire following situations are met:
- Storage knowledge involving arrays or structs is distributed on to an exterior operate name, to abi.encode or to occasion knowledge with out prior task to a neighborhood (reminiscence) variable AND
- there’s an array that comprises components with dimension lower than 32 bytes or a struct that has components that share a storage slot or members of sort bytesNN shorter than 32 bytes.
Along with that, within the following conditions, your code is NOT affected:
- if all of your structs or arrays solely use uint256 or int256 sorts
- in the event you solely use integer sorts (that could be shorter) and solely encode at most one array at a time
- in the event you solely return such knowledge and don’t use it in abi.encode, exterior calls or occasion knowledge.
In case you have a contract that meets these situations, and need to confirm whether or not the contract is certainly susceptible, you may attain out to us by way of security@ethereum.org.
Methods to forestall a lot of these flaws sooner or later
With the intention to be conservative about modifications, the experimental ABI encoder has been obtainable solely when explicitly enabled, to permit folks to work together with it and check it with out placing an excessive amount of belief in it earlier than it’s thought of secure.
We do our greatest to make sure top quality, and have just lately began engaged on ‘semantic’ fuzzing of sure elements on OSS-Fuzz (we’ve beforehand crash-fuzzed the compiler, however that didn’t check compiler correctness).
For builders — bugs inside the Solidity compiler are tough to detect with instruments like vulnerability detectors, since instruments which function on supply code or AST-representations don’t detect flaws which can be launched solely into the compiled bytecode.
One of the simplest ways to guard towards a lot of these flaws is to have a rigorous set of end-to-end checks in your contracts (verifying all code paths), since bugs in a compiler very seemingly will not be “silent” and as an alternative manifest in invalid knowledge.
Doable penalties
Naturally, any bug can have wildly various penalties relying on this system management circulate, however we anticipate that that is extra prone to result in malfunction than exploitability.
The bug, when triggered, will beneath sure circumstances ship corrupt parameters on methodology invocations to different contracts.
Timeline
2019-03-16:
- Report by way of bug bounty, about corruption induced when studying from arrays of booleans straight from storage into ABI encoder.
2019-03-16 to 2019-03-21:
- Investigation of root trigger, evaluation of affected contracts. An unexpectedly excessive depend of contracts compiled with the experimental encoder had been discovered deployed on mainnet, many with out verified source-code.
- Investigation of bug discovered extra methods to set off the bug, e.g. utilizing structs. Moreover, an array overflow bug was present in the identical routine.
- A handful of contracts discovered on Github had been checked, and none had been discovered to be affected.
- A bugfix to the ABI encoder was made.
2019-03-20:
- Resolution to make data public.
- Reasoning: It could not be possible to detect all susceptible contracts and attain out to all authors in a well timed method, and it could be good to stop additional proliferation of susceptible contracts on mainnet.
2019-03-26:
- New compiler launch, model 0.5.7.
- This publish launched.
Technical particulars
Background
The Contract ABI is a specification how knowledge could be exchanged with contracts from the skin (a Dapp) or when interacting between contracts. It helps quite a lot of kinds of knowledge, together with easy values like numbers, bytes and strings, in addition to extra advanced knowledge sorts, together with arrays and structs.
When a contract receives enter knowledge, it should decode that (that is accomplished by the “ABI decoder”) and previous to returning knowledge or sending knowledge to a different contract, it should encode it (that is accomplished by the “ABI encoder”). The Solidity compiler generates these two items of code for every outlined operate in a contract (and likewise for abi.encode and abi.decode). Within the Solidity compiler the subsystem producing the encoder and decoder is known as the “ABI encoder”.
In mid-2017 the Solidity staff began to work on a contemporary implementation named “ABI encoder V2” with the purpose of getting a extra versatile, protected, performant and auditable code generator. This experimental code generator, when explicitly enabled, has been provided to customers because the finish of 2017 with the 0.4.19 launch.
The flaw
The experimental ABI encoder doesn’t deal with non-integer values shorter than 32 bytes correctly. This is applicable to bytesNN sorts, bool, enum and different sorts when they’re a part of an array or a struct and encoded straight from storage. This implies these storage references have for use straight inside abi.encode(…), as arguments in exterior operate calls or in occasion knowledge with out prior task to a neighborhood variable. Utilizing return doesn’t set off the bug. The categories bytesNN and bool will lead to corrupted knowledge whereas enum may result in an invalid revert.
Moreover, arrays with components shorter than 32 bytes is probably not dealt with accurately even when the bottom sort is an integer sort. Encoding such arrays in the best way described above can result in different knowledge within the encoding being overwritten if the variety of components encoded isn’t a a number of of the variety of components that match a single slot. If nothing follows the array within the encoding (word that dynamically-sized arrays are all the time encoded after statically-sized arrays with statically-sized content material), or if solely a single array is encoded, no different knowledge is overwritten.
Unrelated to the ABI encoder subject defined above, two bugs have been discovered within the optimiser. Each have been launched with 0.5.5 (launched on fifth of March). They’re unlikely to happen in code generated by the compiler, until inline meeting is used.
These two bugs have been recognized by means of the latest addition of Solidity to OSS-Fuzz – a safety toolkit for locating discrepancies or points in quite a lot of initiatives. For Solidity we’ve included a number of completely different fuzzers testing completely different points of the compiler.
- The optimizer turns opcode sequences like ((x << a) << b)), the place a and b are compile-time constants, into (x << (a + b)) whereas not dealing with overflow within the addition correctly.
- The optimizer incorrectly handles the byte opcode if the fixed 31 is used as second argument. This will occur when performing index entry on bytesNN sorts with a compile-time fixed worth (not index) of 31 or when utilizing the byte opcode in inline meeting.
This publish was collectively composed by @axic, @chriseth, @holiman