cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add New->Old code gen comparator fuzzer

Browse Source
This commit is contained in:
Bhargava Shastry 2021-04-08 16:15:43 +02:00
parent 68f5632ddd
commit d5364e43ea
2 changed files with 315 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
test/tools/ossfuzz/CMakeLists.txt
View File

@ -2,6 +2,7 @@ add_custom_target(ossfuzz)
add_dependencies(ossfuzz
solc_ossfuzz
bytecode_optimizer_ossfuzz
solc_reverse_ossfuzz
solc_mutator_ossfuzz
const_opt_ossfuzz
strictasm_diff_ossfuzz
@ -35,6 +36,22 @@ if (OSSFUZZ)
)
target_link_libraries(solc_ossfuzz PRIVATE libsolc evmasm evmc evmone-standalone abicoder gmp.a)
set_target_properties(solc_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
target_include_directories(solc_ossfuzz PRIVATE
/home/bhargava/work/github/solidity/deps/libabicoder
)
set_target_properties(solc_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
add_executable(solc_reverse_ossfuzz
solc_reverse_ossfuzz.cpp
ValueGenerator.cpp
../fuzzer_common.cpp
../../TestCaseReader.cpp
../../EVMHost.cpp
SolidityEvmoneInterface.cpp
../../libsolidity/util/ContractABIUtils.cpp
)
target_link_libraries(solc_reverse_ossfuzz PRIVATE libsolc evmasm evmc evmone-standalone abicoder gmp.a)
set_target_properties(solc_reverse_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE})
add_executable(bytecode_optimizer_ossfuzz
BytecodeOptimizerFuzzer.cpp

298
test/tools/ossfuzz/solc_reverse_ossfuzz.cpp Normal file
View File

@ -0,0 +1,298 @@
/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
// SPDX-License-Identifier: GPL-3.0
#include <test/tools/fuzzer_common.h>
#include <test/tools/ossfuzz/SolidityEvmoneInterface.h>
#include <test/tools/ossfuzz/ValueGenerator.h>
#include <test/TestCaseReader.h>
#include <libsolidity/util/ContractABIUtils.h>
#include <libyul/backends/evm/EVMCodeTransform.h>
#include <liblangutil/EVMVersion.h>
#include <evmone/evmone.h>
#include <abicoder.hpp>
#include <regex>
#include <sstream>
using namespace solidity::frontend::test;
using namespace solidity::frontend;
using namespace solidity::test::fuzzer;
using namespace solidity::langutil;
using namespace solidity::test;
using namespace std;
// Prototype as we can't use the FuzzerInterface.h header.
extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size);
static evmc::VM evmone = evmc::VM{evmc_create_evmone()};
static constexpr size_t abiCoderHeapSize = 1024 * 512;
namespace
{
string abiEncoding(
Json::Value const& _functionABI,
map<h160, vector<string>> _addressSelectors,
Json::Value const& _methodIdentifiers
)
{
string abiTypeString;
string abiValueString;
tie(abiTypeString, abiValueString) = ValueGenerator{
_functionABI["inputs"],
0,
std::move(_addressSelectors)
}.type();
string encodedData;
// A function with inputs must contain type names within
// parentheses.
bool functionWithInputs = abiTypeString != "()";
string functionSignature = _functionABI["name"].asString() + abiTypeString;
cout << functionSignature << endl;
string encoding = _methodIdentifiers[functionSignature].asString();
if (functionWithInputs)
{
abicoder::ABICoder coder(abiCoderHeapSize);
auto [status, data] = coder.encode(abiTypeString, abiValueString);
cout << abiTypeString << endl;
cout << abiValueString << endl;
solAssert(status, "Isabelle coder: failed.");
encoding += data.substr(2, data.size());
}
return encoding;
}
}
extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size)
{
string input(reinterpret_cast<char const*>(_data), _size);
regex re = regex("library\\s*(\\w+)\\s*\\{");
smatch matches;
std::string libraryName;
auto match = regex_search(input, matches, re);
if (match && matches[1].matched)
libraryName = matches[1].str();
map<string, string> sourceCode;
try
{
EVMVersion version;
EVMHost hostContext(version, evmone);
TestCaseReader t = TestCaseReader(std::istringstream(input));
sourceCode = t.sources().sources;
string contractName;
string methodName;
auto compilerSetting = OptimiserSettings::standard();
CompilerInput cInput = {
version,
sourceCode,
contractName,
compilerSetting,
{},
true,
true
};
EvmoneUtility evmoneUtil(
hostContext,
cInput,
contractName,
libraryName,
methodName
);
map<h160, vector<string>> addressSelector;
// Add pre-compiles
for (auto const& account: hostContext.accounts)
addressSelector[EVMHost::convertFromEVMC(account.first)] = {};
optional<EvmoneUtility::LibraryStatus> libraryInfo;
vector<string> libraryFunctionSelectors;
if (!libraryName.empty()) {
cout << "Deploying library" << endl;
libraryInfo = evmoneUtil.compileAndDeployLibrary();
if (!libraryInfo.has_value() || get<0>(libraryInfo.value()) != EVMC_SUCCESS)
return 0;
// Add library functions to address selector
libraryFunctionSelectors = get<2>(libraryInfo.value());
if (!libraryFunctionSelectors.empty())
addressSelector[get<1>(libraryInfo.value())] = libraryFunctionSelectors;
cout << "Deployed" << endl;
}
auto compilerOutput = evmoneUtil.compileContract();
if (!compilerOutput.has_value())
return 0;
auto r = evmoneUtil.randomFunction(_size);
if (!r.has_value())
return 0;
auto deployResult = evmoneUtil.deployContract(compilerOutput->byteCode);
if (deployResult.status_code != EVMC_SUCCESS)
return 0;
// Record function selectors in contract
vector<string> functionSelectors;
for (auto const& item: compilerOutput->methodIdentifiersInContract)
functionSelectors.push_back(item.asString());
// Add deployed contract to list of address literals.
addressSelector[EVMHost::convertFromEVMC(deployResult.create_address)] = functionSelectors;
string encodedData = abiEncoding(r.value(), addressSelector,
compilerOutput->methodIdentifiersInContract);
auto callResult = evmoneUtil.executeContract(
solidity::util::fromHex(encodedData),
deployResult.create_address
);
if (callResult.status_code != EVMC_SUCCESS) {
cout << "New code gen call failed with status code: "
<< callResult.status_code
<< endl;
return 0;
}
solidity::bytes result;
for (size_t i = 0; i < callResult.output_size; i++)
result.push_back(callResult.output_data[i]);
EVMHostPrinter p(hostContext, deployResult.create_address);
ostringstream oldCodeGen;
oldCodeGen << p.state();
// Reset call state post old code gen run
hostContext.reset();
addressSelector.clear();
bool libraryFunctions = !libraryFunctionSelectors.empty();
libraryFunctionSelectors.clear();
evmoneUtil.optSetting(compilerSetting);
evmoneUtil.viaIR(false);
// Add pre-compiles post reset
for (auto const& account: hostContext.accounts)
addressSelector[EVMHost::convertFromEVMC(account.first)] = {};
optional<EvmoneUtility::LibraryStatus> libraryInfoNew;
if (!libraryName.empty())
{
libraryInfoNew = evmoneUtil.compileAndDeployLibrary();
solAssert(
libraryInfoNew.has_value() && get<0>(libraryInfoNew.value()) == EVMC_SUCCESS,
"Deploying library failed for the second time"
);
libraryFunctionSelectors = get<2>(libraryInfoNew.value());
// Library functions in both runs should either be both empty or
// both non-empty.
solAssert(
(
(libraryFunctions && !libraryFunctionSelectors.empty()) ||
(!libraryFunctions && libraryFunctionSelectors.empty())
),
"Library function mismatch."
);
if (!libraryFunctionSelectors.empty())
addressSelector[get<1>(libraryInfoNew.value())] = libraryFunctionSelectors;
}
auto compilerOutputOpt = evmoneUtil.compileContract();
solAssert(
compilerOutputOpt.has_value(),
"Contract could not be optimised via old code gen."
);
auto deployResultOpt = evmoneUtil.deployContract(compilerOutputOpt->byteCode);
solAssert(
deployResultOpt.status_code == EVMC_SUCCESS,
"Contract optimised via old code gen could not be deployed."
);
// Add address literal of contract compiled via Yul IR.
addressSelector[EVMHost::convertFromEVMC(deployResultOpt.create_address)] = functionSelectors;
string encodedDataIR = abiEncoding(r.value(), addressSelector,
compilerOutput->methodIdentifiersInContract);
auto callResultOpt = evmoneUtil.executeContract(
solidity::util::fromHex(encodedDataIR),
deployResultOpt.create_address
);
solAssert(
callResultOpt.status_code == EVMC_SUCCESS,
"Old code gen contract call failed."
);
solidity::bytes resultOpt;
for (size_t i = 0; i < callResultOpt.output_size; i++)
resultOpt.push_back(callResultOpt.output_data[i]);
if (result != resultOpt)
{
cout << solidity::util::toHex(result) << endl;
cout << solidity::util::toHex(resultOpt) << endl;
}
solAssert(
result == resultOpt,
"Old and new code gen call results do not match."
);
EVMHostPrinter pOpt(hostContext, deployResultOpt.create_address);
ostringstream newCodeGen;
newCodeGen << pOpt.state();
if (oldCodeGen.str() != newCodeGen.str())
{
cout << oldCodeGen.str() << endl;
cout << newCodeGen.str() << endl;
}
solAssert(
oldCodeGen.str() == newCodeGen.str(),
"Old and new code gen state do not match."
);
return 0;
}
catch (runtime_error const&)
{
cout << "Runtime error!" << endl;
return 0;
}
catch (solidity::langutil::UnimplementedFeatureError const&)
{
cout << "Unimplemented feature!" << endl;
return 0;
}
catch (solidity::langutil::CompilerError const& _e)
{
cout << "Compiler error!" << endl;
cout << _e.what() << endl;
return 0;
}
catch (solidity::yul::StackTooDeepError const&)
{
cout << "Stack too deep" << endl;
return 0;
}
}