d0s3t3ch/wownero
1
0
Fork 0
mirror of https://git.wownero.com/wownero/wownero.git synced 2024-08-15 01:03:23 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #6535

Browse source 
81773f5 fuzz_tests: refactor and add OSS-Fuzz compatibility (moneromooo-monero)
cb4edc1 cmake: ASAN and PIE don't mix (moneromooo-monero)
This commit is contained in:
luigi1111 2020-05-27 18:27:06 -05:00
commit d6d4a03b85
No known key found for this signature in database
GPG key ID: F4ACA0183641E010
16 changed files with 236 additions and 540 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
CMakeLists.txt
View file

@ -262,6 +262,12 @@ else()
endif()
option(BUILD_DEBUG_UTILITIES "Build debug utilities." DEFAULT_BUILD_DEBUG_UTILITIES)
if(OSSFUZZ)
message(STATUS "Using OSS-Fuzz fuzzing system")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DOSSFUZZ")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOSSFUZZ")
endif()
# Check whether we're on a 32-bit or 64-bit system
if(CMAKE_SIZEOF_VOID_P EQUAL "8")
set(DEFAULT_BUILD_64 ON)
@ -646,7 +652,8 @@ else()
endif()
# linker
if (NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1)))
if (NOT SANITIZE AND NOT (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 9.1)))
# PIE executables randomly crash at startup with ASAN
# Windows binaries die on startup with PIE when compiled with GCC <9.x
add_linker_flag_if_supported(-pie LD_SECURITY_FLAGS)
endif()
@ -768,7 +775,8 @@ else()
endif(ARM)
if(ANDROID AND NOT BUILD_GUI_DEPS STREQUAL "ON" OR IOS)
# random crash on startup when asan is on if pie is enabled
if(NOT SANITIZE AND ANDROID AND NOT BUILD_GUI_DEPS STREQUAL "ON" OR IOS)
#From Android 5: "only position independent executables (PIE) are supported"
message(STATUS "Enabling PIE executable")
set(PIC_FLAG "")

36
tests/fuzz/CMakeLists.txt
View file

@ -34,7 +34,8 @@ target_link_libraries(block_fuzz_tests
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET block_fuzz_tests
PROPERTY
FOLDER "tests")
@ -47,7 +48,8 @@ target_link_libraries(transaction_fuzz_tests
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET transaction_fuzz_tests
PROPERTY
FOLDER "tests")
@ -61,7 +63,8 @@ target_link_libraries(signature_fuzz_tests
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET signature_fuzz_tests
PROPERTY
FOLDER "tests")
@ -75,7 +78,8 @@ target_link_libraries(cold-outputs_fuzz_tests
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET cold-outputs_fuzz_tests
PROPERTY
FOLDER "tests")
@ -89,7 +93,8 @@ target_link_libraries(cold-transaction_fuzz_tests
epee
device
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET cold-transaction_fuzz_tests
PROPERTY
FOLDER "tests")
@ -101,7 +106,8 @@ target_link_libraries(load-from-binary_fuzz_tests
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET load-from-binary_fuzz_tests
PROPERTY
FOLDER "tests")
@ -113,7 +119,8 @@ target_link_libraries(load-from-json_fuzz_tests
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET load-from-json_fuzz_tests
PROPERTY
FOLDER "tests")
@ -125,7 +132,8 @@ target_link_libraries(base58_fuzz_tests
epee
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET base58_fuzz_tests
PROPERTY
FOLDER "tests")
@ -138,7 +146,8 @@ target_link_libraries(parse-url_fuzz_tests
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET parse-url_fuzz_tests
PROPERTY
FOLDER "tests")
@ -153,7 +162,8 @@ target_link_libraries(http-client_fuzz_tests
${Boost_PROGRAM_OPTIONS_LIBRARY}
${Boost_SYSTEM_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET http-client_fuzz_tests
PROPERTY
FOLDER "tests")
@ -168,7 +178,8 @@ target_link_libraries(levin_fuzz_tests
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET levin_fuzz_tests
PROPERTY
FOLDER "tests")
@ -183,7 +194,8 @@ target_link_libraries(bulletproof_fuzz_tests
${Boost_REGEX_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
${CMAKE_THREAD_LIBS_INIT}
${EXTRA_LIBRARIES})
${EXTRA_LIBRARIES}
$ENV{LIB_FUZZING_ENGINE})
set_property(TARGET bulletproof_fuzz_tests
PROPERTY
FOLDER "tests")

47
tests/fuzz/base58.cpp
View file

@ -27,50 +27,13 @@
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "include_base_utils.h"
#include "file_io_utils.h"
#include "common/base58.h"
#include "fuzzer.h"
class Base58Fuzzer: public Fuzzer
{
public:
Base58Fuzzer() {}
virtual int init();
virtual int run(const std::string &filename);
};
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
int Base58Fuzzer::init()
{
return 0;
}
int Base58Fuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
BEGIN_SIMPLE_FUZZER()
std::string data;
tools::base58::decode(s, data);
}
catch (const std::exception &e)
{
std::cerr << "Failed to load from binary: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
Base58Fuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
tools::base58::decode(std::string((const char*)buf, len), data);
END_SIMPLE_FUZZER()

36
tests/fuzz/block.cpp
View file

@ -33,36 +33,10 @@
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "fuzzer.h"
class BlockFuzzer: public Fuzzer
{
public:
virtual int run(const std::string &filename);
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
private:
};
int BlockFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
BEGIN_SIMPLE_FUZZER()
cryptonote::block b = AUTO_VAL_INIT(b);
if(!parse_and_validate_block_from_blob(s, b))
{
std::cout << "Error: failed to parse block from file " << filename << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
BlockFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
parse_and_validate_block_from_blob(std::string((const char*)buf, len), b);
END_SIMPLE_FUZZER()

39
tests/fuzz/bulletproof.cpp
View file

@ -33,40 +33,13 @@
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "fuzzer.h"
class BulletproofFuzzer: public Fuzzer
{
public:
virtual int run(const std::string &filename);
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
private:
};
int BulletproofFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
BEGIN_SIMPLE_FUZZER()
std::stringstream ss;
ss << s;
ss << std::string((const char*)buf, len);
binary_archive<false> ba(ss);
rct::Bulletproof proof = AUTO_VAL_INIT(proof);
bool r = ::serialization::serialize(ba, proof);
if(!r)
{
std::cout << "Error: failed to parse bulletproof from file " << filename << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
BulletproofFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
::serialization::serialize(ba, proof);
END_SIMPLE_FUZZER()

57
tests/fuzz/cold-outputs.cpp
View file

@ -34,49 +34,20 @@
#include "wallet/wallet2.h"
#include "fuzzer.h"
class ColdOutputsFuzzer: public Fuzzer
{
public:
ColdOutputsFuzzer(): wallet(cryptonote::TESTNET) {}
virtual int init();
virtual int run(const std::string &filename);
static tools::wallet2 wallet;
private:
tools::wallet2 wallet;
};
int ColdOutputsFuzzer::init()
{
BEGIN_INIT_SIMPLE_FUZZER()
static const char * const spendkey_hex = "0b4f47697ec99c3de6579304e5f25c68b07afbe55b71d99620bf6cbf4e45a80f";
crypto::secret_key spendkey;
epee::string_tools::hex_to_pod(spendkey_hex, spendkey);
try
{
wallet.init("", boost::none, boost::asio::ip::tcp::endpoint{}, 0, true, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
wallet.set_subaddress_lookahead(1, 1);
wallet.generate("", "", spendkey, true, false);
}
catch (const std::exception &e)
{
std::cerr << "Error on ColdOutputsFuzzer::init: " << e.what() << std::endl;
return 1;
}
return 0;
}
END_INIT_SIMPLE_FUZZER()
int ColdOutputsFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
s = std::string("\x01\x16serialization::archive") + s;
try
{
BEGIN_SIMPLE_FUZZER()
std::string s = std::string("\x01\x16serialization::archive") + std::string((const char*)buf, len);
std::pair<size_t, std::vector<tools::wallet2::transfer_details>> outputs;
std::stringstream iss;
iss << s;
@ -84,20 +55,4 @@ int ColdOutputsFuzzer::run(const std::string &filename)
ar >> outputs;
size_t n_outputs = wallet.import_outputs(outputs);
std::cout << boost::lexical_cast<std::string>(n_outputs) << " outputs imported" << std::endl;
}
catch (const std::exception &e)
{
std::cerr << "Failed to import outputs: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
ColdOutputsFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
END_SIMPLE_FUZZER()

57
tests/fuzz/cold-transaction.cpp
View file

@ -34,50 +34,20 @@
#include "wallet/wallet2.h"
#include "fuzzer.h"
class ColdTransactionFuzzer: public Fuzzer
{
public:
ColdTransactionFuzzer(): wallet(cryptonote::TESTNET) {}
virtual int init();
virtual int run(const std::string &filename);
static tools::wallet2 wallet;
private:
tools::wallet2 wallet;
};
int ColdTransactionFuzzer::init()
{
BEGIN_INIT_SIMPLE_FUZZER()
static const char * const spendkey_hex = "0b4f47697ec99c3de6579304e5f25c68b07afbe55b71d99620bf6cbf4e45a80f";
crypto::secret_key spendkey;
epee::string_tools::hex_to_pod(spendkey_hex, spendkey);
try
{
wallet.init("", boost::none, boost::asio::ip::tcp::endpoint{}, 0, true, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
wallet.set_subaddress_lookahead(1, 1);
wallet.generate("", "", spendkey, true, false);
}
catch (const std::exception &e)
{
std::cerr << "Error on ColdTransactionFuzzer::init: " << e.what() << std::endl;
return 1;
}
return 0;
}
END_INIT_SIMPLE_FUZZER()
int ColdTransactionFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
s = std::string("\x01\x16serialization::archive") + s;
try
{
BEGIN_SIMPLE_FUZZER()
std::string s = std::string("\x01\x16serialization::archive") + std::string((const char*)buf, len);
tools::wallet2::unsigned_tx_set exported_txs;
std::stringstream iss;
iss << s;
@ -86,19 +56,4 @@ int ColdTransactionFuzzer::run(const std::string &filename)
std::vector<tools::wallet2::pending_tx> ptx;
bool success = wallet.sign_tx(exported_txs, "/tmp/cold-transaction-test-signed", ptx);
std::cout << (success ? "signed" : "error") << std::endl;
}
catch (const std::exception &e)
{
std::cerr << "Failed to sign transaction: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
ColdTransactionFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
END_SIMPLE_FUZZER()

4
tests/fuzz/fuzzer.cpp
View file

@ -33,6 +33,8 @@
#include "common/util.h"
#include "fuzzer.h"
#ifndef OSSFUZZ
#if (!defined(__clang__) || (__clang__ < 5))
static int __AFL_LOOP(int)
{
@ -74,3 +76,5 @@ int run_fuzzer(int argc, const char **argv, Fuzzer &fuzzer)
CATCH_ENTRY_L0("run_fuzzer", 1);
}
#endif

100
tests/fuzz/fuzzer.h
View file

@ -27,6 +27,52 @@
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <string>
#include "file_io_utils.h"
#ifdef OSSFUZZ
#define BEGIN_INIT_SIMPLE_FUZZER() \
static int init() \
{ \
try \
{
#define END_INIT_SIMPLE_FUZZER() \
} \
catch (const std::exception &e) \
{ \
fprintf(stderr, "Exception: %s\n", e.what()); \
return 1; \
} \
return 0; \
}
#define BEGIN_SIMPLE_FUZZER() \
extern "C" { \
int LLVMFuzzerTestOneInput(const uint8_t *buf, size_t len) \
{ \
try \
{ \
static bool first = true; \
if (first) \
{ \
if (!init()) \
return 1; \
first = false; \
} \
#define END_SIMPLE_FUZZER() \
} \
catch (const std::exception &e) \
{ \
fprintf(stderr, "Exception: %s\n", e.what()); \
return 1; \
} \
return 0; \
} \
}
#else
class Fuzzer
{
@ -36,3 +82,57 @@ public:
};
int run_fuzzer(int argc, const char **argv, Fuzzer &fuzzer);
#define BEGIN_INIT_SIMPLE_FUZZER() \
class SimpleFuzzer: public Fuzzer \
{ \
virtual int init() \
{ \
try \
{
#define END_INIT_SIMPLE_FUZZER() \
} \
catch (const std::exception &e) \
{ \
fprintf(stderr, "Exception: %s\n", e.what()); \
return 1; \
} \
return 0; \
}
#define BEGIN_SIMPLE_FUZZER() \
virtual int run(const std::string &filename) \
{ \
try \
{ \
std::string s; \
if (!epee::file_io_utils::load_file_to_string(filename, s)) \
{ \
std::cout << "Error: failed to load file " << filename << std::endl; \
return 1; \
} \
const uint8_t *buf = (const uint8_t*)s.data(); \
const size_t len = s.size(); \
{
#define END_SIMPLE_FUZZER() \
} \
} \
catch (const std::exception &e) \
{ \
fprintf(stderr, "Exception: %s\n", e.what()); \
return 1; \
} \
return 0; \
} \
}; \
int main(int argc, const char **argv) \
{ \
TRY_ENTRY(); \
SimpleFuzzer fuzzer; \
return run_fuzzer(argc, argv, fuzzer); \
CATCH_ENTRY_L0("main", 1); \
}
#endif

49
tests/fuzz/http-client.cpp
View file

@ -58,48 +58,11 @@ private:
std::string data;
};
class HTTPClientFuzzer: public Fuzzer
{
public:
HTTPClientFuzzer() {}
virtual int init();
virtual int run(const std::string &filename);
static epee::net_utils::http::http_simple_client_template<dummy_client> client;
private:
epee::net_utils::http::http_simple_client_template<dummy_client> client;
};
int HTTPClientFuzzer::init()
{
return 0;
}
int HTTPClientFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
client.test(s, std::chrono::milliseconds(1000));
}
catch (const std::exception &e)
{
std::cerr << "Failed to test http client: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
HTTPClientFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
BEGIN_SIMPLE_FUZZER()
client.test(std::string((const char*)buf, len), std::chrono::milliseconds(1000));
END_SIMPLE_FUZZER()

49
tests/fuzz/levin.cpp
View file

@ -279,26 +279,10 @@ namespace
#endif
}
class LevinFuzzer: public Fuzzer
{
public:
LevinFuzzer() {} //: handler(endpoint, config, context) {}
virtual int init();
virtual int run(const std::string &filename);
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
private:
//epee::net_utils::connection_context_base context;
//epee::levin::async_protocol_handler<> handler;
};
int LevinFuzzer::init()
{
return 0;
}
int LevinFuzzer::run(const std::string &filename)
{
std::string s;
BEGIN_SIMPLE_FUZZER()
#if 0
epee::levin::bucket_head2 req_head;
@ -313,13 +297,6 @@ int LevinFuzzer::run(const std::string &filename)
fwrite(&req_head,sizeof(req_head),1, f);
fclose(f);
#endif
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
//std::unique_ptr<test_connection> conn = new test();
boost::asio::io_service io_service;
test_levin_protocol_handler_config m_handler_config;
@ -329,21 +306,5 @@ int LevinFuzzer::run(const std::string &filename)
conn->start();
//m_commands_handler.invoke_out_buf(expected_out_data);
//m_commands_handler.return_code(expected_return_code);
conn->m_protocol_handler.handle_recv(s.data(), s.size());
}
catch (const std::exception &e)
{
std::cerr << "Failed to test http client: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
LevinFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
conn->m_protocol_handler.handle_recv(buf, len);
END_SIMPLE_FUZZER()

46
tests/fuzz/load_from_binary.cpp
View file

@ -33,46 +33,10 @@
#include "storages/portable_storage_base.h"
#include "fuzzer.h"
class PortableStorageFuzzer: public Fuzzer
{
public:
PortableStorageFuzzer() {}
virtual int init();
virtual int run(const std::string &filename);
};
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
int PortableStorageFuzzer::init()
{
return 0;
}
int PortableStorageFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
BEGIN_SIMPLE_FUZZER()
epee::serialization::portable_storage ps;
ps.load_from_binary(s);
}
catch (const std::exception &e)
{
std::cerr << "Failed to load from binary: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
PortableStorageFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
ps.load_from_binary(std::string((const char*)buf, len));
END_SIMPLE_FUZZER()

46
tests/fuzz/load_from_json.cpp
View file

@ -33,46 +33,10 @@
#include "storages/portable_storage_base.h"
#include "fuzzer.h"
class PortableStorageFuzzer: public Fuzzer
{
public:
PortableStorageFuzzer() {}
virtual int init();
virtual int run(const std::string &filename);
};
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
int PortableStorageFuzzer::init()
{
return 0;
}
int PortableStorageFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
BEGIN_SIMPLE_FUZZER()
epee::serialization::portable_storage ps;
ps.load_from_json(s);
}
catch (const std::exception &e)
{
std::cerr << "Failed to load from binary: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
PortableStorageFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
ps.load_from_json(std::string((const char*)buf, len));
END_SIMPLE_FUZZER()

46
tests/fuzz/parse_url.cpp
View file

@ -31,46 +31,10 @@
#include "net/net_parse_helpers.h"
#include "fuzzer.h"
class ParseURLFuzzer: public Fuzzer
{
public:
ParseURLFuzzer() {}
virtual int init();
virtual int run(const std::string &filename);
};
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
int ParseURLFuzzer::init()
{
return 0;
}
int ParseURLFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
try
{
BEGIN_SIMPLE_FUZZER()
epee::net_utils::http::url_content url;
epee::net_utils::parse_url(s, url);
}
catch (const std::exception &e)
{
std::cerr << "Failed to load from binary: " << e.what() << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
ParseURLFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
epee::net_utils::parse_url(std::string((const char*)buf, len), url);
END_SIMPLE_FUZZER()

52
tests/fuzz/signature.cpp
View file

@ -34,26 +34,14 @@
#include "wallet/wallet2.h"
#include "fuzzer.h"
class SignatureFuzzer: public Fuzzer
{
public:
SignatureFuzzer(): Fuzzer(), wallet(cryptonote::TESTNET) {}
virtual int init();
virtual int run(const std::string &filename);
static tools::wallet2 wallet(cryptonote::TESTNET);
static cryptonote::account_public_address address;
private:
tools::wallet2 wallet;
cryptonote::account_public_address address;
};
int SignatureFuzzer::init()
{
BEGIN_INIT_SIMPLE_FUZZER()
static const char * const spendkey_hex = "0b4f47697ec99c3de6579304e5f25c68b07afbe55b71d99620bf6cbf4e45a80f";
crypto::secret_key spendkey;
epee::string_tools::hex_to_pod(spendkey_hex, spendkey);
try
{
wallet.init("", boost::none, boost::asio::ip::tcp::endpoint{}, 0, true, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
wallet.set_subaddress_lookahead(1, 1);
wallet.generate("", "", spendkey, true, false);
@ -65,35 +53,9 @@ int SignatureFuzzer::init()
return 1;
}
address = info.address;
}
catch (const std::exception &e)
{
std::cerr << "Error on SignatureFuzzer::init: " << e.what() << std::endl;
return 1;
}
return 0;
}
END_INIT_SIMPLE_FUZZER()
int SignatureFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
bool valid = wallet.verify("test", address, s);
BEGIN_SIMPLE_FUZZER()
bool valid = wallet.verify("test", address, std::string((const char*)buf, len));
std::cout << "Signature " << (valid ? "valid" : "invalid") << std::endl;
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
SignatureFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
END_SIMPLE_FUZZER()

36
tests/fuzz/transaction.cpp
View file

@ -33,36 +33,10 @@
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "fuzzer.h"
class TransactionFuzzer: public Fuzzer
{
public:
virtual int run(const std::string &filename);
BEGIN_INIT_SIMPLE_FUZZER()
END_INIT_SIMPLE_FUZZER()
private:
};
int TransactionFuzzer::run(const std::string &filename)
{
std::string s;
if (!epee::file_io_utils::load_file_to_string(filename, s))
{
std::cout << "Error: failed to load file " << filename << std::endl;
return 1;
}
BEGIN_SIMPLE_FUZZER()
cryptonote::transaction tx = AUTO_VAL_INIT(tx);
if(!parse_and_validate_tx_from_blob(s, tx))
{
std::cout << "Error: failed to parse transaction from file " << filename << std::endl;
return 1;
}
return 0;
}
int main(int argc, const char **argv)
{
TRY_ENTRY();
TransactionFuzzer fuzzer;
return run_fuzzer(argc, argv, fuzzer);
CATCH_ENTRY_L0("main", 1);
}
parse_and_validate_tx_from_blob(std::string((const char*)buf, len), tx);
END_SIMPLE_FUZZER()