From 296ae46ed8f8f6e5f986f978febad302e3df231a Mon Sep 17 00:00:00 2001 From: Antonio Juarez Date: Mon, 3 Mar 2014 22:07:58 +0000 Subject: moved all stuff to github --- tests/core_tests/integer_overflow.cpp | 184 ++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 tests/core_tests/integer_overflow.cpp (limited to 'tests/core_tests/integer_overflow.cpp') diff --git a/tests/core_tests/integer_overflow.cpp b/tests/core_tests/integer_overflow.cpp new file mode 100644 index 000000000..82bfb2150 --- /dev/null +++ b/tests/core_tests/integer_overflow.cpp @@ -0,0 +1,184 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +#include "integer_overflow.h" + +using namespace epee; +using namespace cryptonote; + +namespace +{ + void split_miner_tx_outs(transaction& miner_tx, uint64_t amount_1) + { + uint64_t total_amount = get_outs_money_amount(miner_tx); + uint64_t amount_2 = total_amount - amount_1; + txout_target_v target = miner_tx.vout[0].target; + + miner_tx.vout.clear(); + + tx_out out1; + out1.amount = amount_1; + out1.target = target; + miner_tx.vout.push_back(out1); + + tx_out out2; + out2.amount = amount_2; + out2.target = target; + miner_tx.vout.push_back(out2); + } + + void append_tx_source_entry(std::vector& sources, const transaction& tx, size_t out_idx) + { + cryptonote::tx_source_entry se; + se.amount = tx.vout[out_idx].amount; + se.outputs.push_back(std::make_pair(0, boost::get(tx.vout[out_idx].target).key)); + se.real_output = 0; + se.real_out_tx_key = get_tx_pub_key_from_extra(tx); + se.real_output_in_tx_index = out_idx; + + sources.push_back(se); + } +} + +//====================================================================================================================== + +gen_uint_overflow_base::gen_uint_overflow_base() + : m_last_valid_block_event_idx(static_cast(-1)) +{ + REGISTER_CALLBACK_METHOD(gen_uint_overflow_1, mark_last_valid_block); +} + +bool gen_uint_overflow_base::check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& /*tx*/) +{ + return m_last_valid_block_event_idx < event_idx ? !tx_added && tvc.m_verifivation_failed : tx_added && !tvc.m_verifivation_failed; +} + +bool gen_uint_overflow_base::check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*block*/) +{ + return m_last_valid_block_event_idx < event_idx ? bvc.m_verifivation_failed | bvc.m_marked_as_orphaned : !bvc.m_verifivation_failed; +} + +bool gen_uint_overflow_base::mark_last_valid_block(cryptonote::core& c, size_t ev_index, const std::vector& events) +{ + m_last_valid_block_event_idx = ev_index - 1; + return true; +} + +//====================================================================================================================== + +bool gen_uint_overflow_1::generate(std::vector& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + DO_CALLBACK(events, "mark_last_valid_block"); + MAKE_ACCOUNT(events, bob_account); + MAKE_ACCOUNT(events, alice_account); + + // Problem 1. Miner tx output overflow + MAKE_MINER_TX_MANUALLY(miner_tx_0, blk_0); + split_miner_tx_outs(miner_tx_0, MONEY_SUPPLY); + block blk_1; + if (!generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx_0)) + return false; + events.push_back(blk_1); + + // Problem 1. Miner tx outputs overflow + MAKE_MINER_TX_MANUALLY(miner_tx_1, blk_1); + split_miner_tx_outs(miner_tx_1, MONEY_SUPPLY); + block blk_2; + if (!generator.construct_block_manually(blk_2, blk_1, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx_1)) + return false; + events.push_back(blk_2); + + REWIND_BLOCKS(events, blk_2r, blk_2, miner_account); + MAKE_TX_LIST_START(events, txs_0, miner_account, bob_account, MONEY_SUPPLY, blk_2); + MAKE_TX_LIST(events, txs_0, miner_account, bob_account, MONEY_SUPPLY, blk_2); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_2r, miner_account, txs_0); + REWIND_BLOCKS(events, blk_3r, blk_3, miner_account); + + // Problem 2. total_fee overflow, block_reward overflow + std::list txs_1; + // Create txs with huge fee + txs_1.push_back(construct_tx_with_fee(events, blk_3, bob_account, alice_account, MK_COINS(1), MONEY_SUPPLY - MK_COINS(1))); + txs_1.push_back(construct_tx_with_fee(events, blk_3, bob_account, alice_account, MK_COINS(1), MONEY_SUPPLY - MK_COINS(1))); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_4, blk_3r, miner_account, txs_1); + + return true; +} + +//====================================================================================================================== + +bool gen_uint_overflow_2::generate(std::vector& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + MAKE_ACCOUNT(events, bob_account); + MAKE_ACCOUNT(events, alice_account); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + DO_CALLBACK(events, "mark_last_valid_block"); + + // Problem 1. Regular tx outputs overflow + std::vector sources; + for (size_t i = 0; i < blk_0.miner_tx.vout.size(); ++i) + { + if (TESTS_DEFAULT_FEE < blk_0.miner_tx.vout[i].amount) + { + append_tx_source_entry(sources, blk_0.miner_tx, i); + break; + } + } + if (sources.empty()) + { + return false; + } + + std::vector destinations; + const account_public_address& bob_addr = bob_account.get_keys().m_account_address; + destinations.push_back(tx_destination_entry(MONEY_SUPPLY, bob_addr)); + destinations.push_back(tx_destination_entry(MONEY_SUPPLY - 1, bob_addr)); + // sources.front().amount = destinations[0].amount + destinations[2].amount + destinations[3].amount + TESTS_DEFAULT_FEE + destinations.push_back(tx_destination_entry(sources.front().amount - MONEY_SUPPLY - MONEY_SUPPLY + 1 - TESTS_DEFAULT_FEE, bob_addr)); + + cryptonote::transaction tx_1; + if (!construct_tx(miner_account.get_keys(), sources, destinations, tx_1, 0)) + return false; + events.push_back(tx_1); + + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_account, tx_1); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + // Problem 2. Regular tx inputs overflow + sources.clear(); + for (size_t i = 0; i < tx_1.vout.size(); ++i) + { + auto& tx_1_out = tx_1.vout[i]; + if (tx_1_out.amount < MONEY_SUPPLY - 1) + continue; + + append_tx_source_entry(sources, tx_1, i); + } + + destinations.clear(); + cryptonote::tx_destination_entry de; + de.addr = alice_account.get_keys().m_account_address; + de.amount = MONEY_SUPPLY - TESTS_DEFAULT_FEE; + destinations.push_back(de); + destinations.push_back(de); + + cryptonote::transaction tx_2; + if (!construct_tx(bob_account.get_keys(), sources, destinations, tx_2, 0)) + return false; + events.push_back(tx_2); + + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, miner_account, tx_2); + + return true; +} -- cgit v1.2.3