540a76c5c2
The functions in src/cryptonote_core/checkpoints_create.{h,cpp} should
be member functions of the checkpoints class, if nothing else for the
sake of keeping their documentation together.
This commit covers moving those functions to be member functions of the
checkpoints class as well as documenting those functions.
361 lines
13 KiB
C++
361 lines
13 KiB
C++
// Copyright (c) 2014-2016, The Monero Project
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
// materials provided with the distribution.
|
|
//
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
// used to endorse or promote products derived from this software without specific
|
|
// prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
|
|
|
#include "include_base_utils.h"
|
|
|
|
using namespace epee;
|
|
|
|
#include "checkpoints.h"
|
|
|
|
#include "common/dns_utils.h"
|
|
#include "include_base_utils.h"
|
|
#include <sstream>
|
|
#include <random>
|
|
|
|
namespace
|
|
{
|
|
bool dns_records_match(const std::vector<std::string>& a, const std::vector<std::string>& b)
|
|
{
|
|
if (a.size() != b.size()) return false;
|
|
|
|
for (const auto& record_in_a : a)
|
|
{
|
|
bool ok = false;
|
|
for (const auto& record_in_b : b)
|
|
{
|
|
if (record_in_a == record_in_b)
|
|
{
|
|
ok = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!ok) return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
} // anonymous namespace
|
|
|
|
namespace cryptonote
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
checkpoints::checkpoints()
|
|
{
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool checkpoints::add_checkpoint(uint64_t height, const std::string& hash_str)
|
|
{
|
|
crypto::hash h = null_hash;
|
|
bool r = epee::string_tools::parse_tpod_from_hex_string(hash_str, h);
|
|
CHECK_AND_ASSERT_MES(r, false, "Failed to parse checkpoint hash string into binary representation!");
|
|
|
|
// return false if adding at a height we already have AND the hash is different
|
|
if (m_points.count(height))
|
|
{
|
|
CHECK_AND_ASSERT_MES(h == m_points[height], false, "Checkpoint at given height already exists, and hash for new checkpoint was different!");
|
|
}
|
|
m_points[height] = h;
|
|
return true;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool checkpoints::is_in_checkpoint_zone(uint64_t height) const
|
|
{
|
|
return !m_points.empty() && (height <= (--m_points.end())->first);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool checkpoints::check_block(uint64_t height, const crypto::hash& h, bool& is_a_checkpoint) const
|
|
{
|
|
auto it = m_points.find(height);
|
|
is_a_checkpoint = it != m_points.end();
|
|
if(!is_a_checkpoint)
|
|
return true;
|
|
|
|
if(it->second == h)
|
|
{
|
|
LOG_PRINT_GREEN("CHECKPOINT PASSED FOR HEIGHT " << height << " " << h, LOG_LEVEL_1);
|
|
return true;
|
|
}else
|
|
{
|
|
LOG_ERROR("CHECKPOINT FAILED FOR HEIGHT " << height << ". EXPECTED HASH: " << it->second << ", FETCHED HASH: " << h);
|
|
return false;
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
bool checkpoints::check_block(uint64_t height, const crypto::hash& h) const
|
|
{
|
|
bool ignored;
|
|
return check_block(height, h, ignored);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//FIXME: is this the desired behavior?
|
|
bool checkpoints::is_alternative_block_allowed(uint64_t blockchain_height, uint64_t block_height) const
|
|
{
|
|
if (0 == block_height)
|
|
return false;
|
|
|
|
auto it = m_points.upper_bound(blockchain_height);
|
|
// Is blockchain_height before the first checkpoint?
|
|
if (it == m_points.begin())
|
|
return true;
|
|
|
|
--it;
|
|
uint64_t checkpoint_height = it->first;
|
|
return checkpoint_height < block_height;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
uint64_t checkpoints::get_max_height() const
|
|
{
|
|
std::map< uint64_t, crypto::hash >::const_iterator highest =
|
|
std::max_element( m_points.begin(), m_points.end(),
|
|
( boost::bind(&std::map< uint64_t, crypto::hash >::value_type::first, _1) <
|
|
boost::bind(&std::map< uint64_t, crypto::hash >::value_type::first, _2 ) ) );
|
|
return highest->first;
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
const std::map<uint64_t, crypto::hash>& checkpoints::get_points() const
|
|
{
|
|
return m_points;
|
|
}
|
|
|
|
bool checkpoints::check_for_conflicts(const checkpoints& other) const
|
|
{
|
|
for (auto& pt : other.get_points())
|
|
{
|
|
if (m_points.count(pt.first))
|
|
{
|
|
CHECK_AND_ASSERT_MES(pt.second == m_points.at(pt.first), false, "Checkpoint at given height already exists, and hash for new checkpoint was different!");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool checkpoints::init_default_checkpoints()
|
|
{
|
|
ADD_CHECKPOINT(1, "771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821a8148");
|
|
ADD_CHECKPOINT(10, "c0e3b387e47042f72d8ccdca88071ff96bff1ac7cde09ae113dbb7ad3fe92381");
|
|
ADD_CHECKPOINT(100, "ac3e11ca545e57c49fca2b4e8c48c03c23be047c43e471e1394528b1f9f80b2d");
|
|
ADD_CHECKPOINT(1000, "5acfc45acffd2b2e7345caf42fa02308c5793f15ec33946e969e829f40b03876");
|
|
ADD_CHECKPOINT(10000, "c758b7c81f928be3295d45e230646de8b852ec96a821eac3fea4daf3fcac0ca2");
|
|
ADD_CHECKPOINT(22231, "7cb10e29d67e1c069e6e11b17d30b809724255fee2f6868dc14cfc6ed44dfb25");
|
|
ADD_CHECKPOINT(29556, "53c484a8ed91e4da621bb2fa88106dbde426fe90d7ef07b9c1e5127fb6f3a7f6");
|
|
ADD_CHECKPOINT(50000, "0fe8758ab06a8b9cb35b7328fd4f757af530a5d37759f9d3e421023231f7b31c");
|
|
ADD_CHECKPOINT(80000, "a62dcd7b536f22e003ebae8726e9e7276f63d594e264b6f0cd7aab27b66e75e3");
|
|
ADD_CHECKPOINT(202612, "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698");
|
|
ADD_CHECKPOINT(202613, "e2aa337e78df1f98f462b3b1e560c6b914dec47b610698b7b7d1e3e86b6197c2");
|
|
ADD_CHECKPOINT(202614, "c29e3dc37d8da3e72e506e31a213a58771b24450144305bcba9e70fa4d6ea6fb");
|
|
ADD_CHECKPOINT(205000, "5d3d7a26e6dc7535e34f03def711daa8c263785f73ec1fadef8a45880fde8063");
|
|
ADD_CHECKPOINT(220000, "9613f455933c00e3e33ac315cc6b455ee8aa0c567163836858c2d9caff111553");
|
|
ADD_CHECKPOINT(230300, "bae7a80c46859db355556e3a9204a337ae8f24309926a1312323fdecf1920e61");
|
|
ADD_CHECKPOINT(230700, "93e631240ceac831da1aebfc5dac8f722c430463024763ebafa888796ceaeedf");
|
|
ADD_CHECKPOINT(231350, "b5add137199b820e1ea26640e5c3e121fd85faa86a1e39cf7e6cc097bdeb1131");
|
|
ADD_CHECKPOINT(232150, "955de8e6b6508af2c24f7334f97beeea651d78e9ade3ab18fec3763be3201aa8");
|
|
ADD_CHECKPOINT(249380, "654fb0a81ce3e5caf7e3264a70f447d4bd07586c08fa50f6638cc54da0a52b2d");
|
|
ADD_CHECKPOINT(460000, "75037a7aed3e765db96c75bcf908f59d690a5f3390baebb9edeafd336a1c4831");
|
|
ADD_CHECKPOINT(500000, "2428f0dbe49796be05ed81b347f53e1f7f44aed0abf641446ec2b94cae066b02");
|
|
ADD_CHECKPOINT(600000, "f5828ebf7d7d1cb61762c4dfe3ccf4ecab2e1aad23e8113668d981713b7a54c5");
|
|
ADD_CHECKPOINT(700000, "12be9b3d210b93f574d2526abb9c1ab2a881b479131fd0d4f7dac93875f503cd");
|
|
ADD_CHECKPOINT(825000, "56503f9ad766774b575be3aff73245e9d159be88132c93d1754764f28da2ff60");
|
|
ADD_CHECKPOINT(900000, "d9958d0e7dcf91a5a7b11de225927bf7efc6eb26240315ce12372be902cc1337");
|
|
ADD_CHECKPOINT(913193, "5292d5d56f6ba4de33a58d9a34d263e2cb3c6fee0aed2286fd4ac7f36d53c85f");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool checkpoints::load_checkpoints_from_json(const std::string json_hashfile_fullpath)
|
|
{
|
|
boost::system::error_code errcode;
|
|
if (! (boost::filesystem::exists(json_hashfile_fullpath, errcode)))
|
|
{
|
|
LOG_PRINT_L1("Blockchain checkpoints file not found");
|
|
return true;
|
|
}
|
|
|
|
LOG_PRINT_L1("Adding checkpoints from blockchain hashfile");
|
|
|
|
uint64_t prev_max_height = get_max_height();
|
|
LOG_PRINT_L1("Hard-coded max checkpoint height is " << prev_max_height);
|
|
t_hash_json hashes;
|
|
epee::serialization::load_t_from_json_file(hashes, json_hashfile_fullpath);
|
|
for (std::vector<t_hashline>::const_iterator it = hashes.hashlines.begin(); it != hashes.hashlines.end(); )
|
|
{
|
|
uint64_t height;
|
|
height = it->height;
|
|
if (height <= prev_max_height) {
|
|
LOG_PRINT_L1("ignoring checkpoint height " << height);
|
|
} else {
|
|
std::string blockhash = it->hash;
|
|
LOG_PRINT_L1("Adding checkpoint height " << height << ", hash=" << blockhash);
|
|
ADD_CHECKPOINT(height, blockhash);
|
|
}
|
|
++it;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool checkpoints::load_checkpoints_from_dns(bool testnet)
|
|
{
|
|
// All four MoneroPulse domains have DNSSEC on and valid
|
|
static const std::vector<std::string> dns_urls = { "checkpoints.moneropulse.se"
|
|
, "checkpoints.moneropulse.org"
|
|
, "checkpoints.moneropulse.net"
|
|
, "checkpoints.moneropulse.co"
|
|
};
|
|
|
|
static const std::vector<std::string> testnet_dns_urls = { "testpoints.moneropulse.se"
|
|
, "testpoints.moneropulse.org"
|
|
, "testpoints.moneropulse.net"
|
|
, "testpoints.moneropulse.co"
|
|
};
|
|
|
|
std::vector<std::vector<std::string> > records;
|
|
records.resize(dns_urls.size());
|
|
|
|
std::random_device rd;
|
|
std::mt19937 gen(rd());
|
|
std::uniform_int_distribution<int> dis(0, dns_urls.size() - 1);
|
|
size_t first_index = dis(gen);
|
|
|
|
bool avail, valid;
|
|
size_t cur_index = first_index;
|
|
do
|
|
{
|
|
std::string url;
|
|
if (testnet)
|
|
{
|
|
url = testnet_dns_urls[cur_index];
|
|
}
|
|
else
|
|
{
|
|
url = dns_urls[cur_index];
|
|
}
|
|
|
|
records[cur_index] = tools::DNSResolver::instance().get_txt_record(url, avail, valid);
|
|
if (!avail)
|
|
{
|
|
records[cur_index].clear();
|
|
LOG_PRINT_L2("DNSSEC not available for checkpoint update at URL: " << url << ", skipping.");
|
|
}
|
|
if (!valid)
|
|
{
|
|
records[cur_index].clear();
|
|
LOG_PRINT_L2("DNSSEC validation failed for checkpoint update at URL: " << url << ", skipping.");
|
|
}
|
|
|
|
cur_index++;
|
|
if (cur_index == dns_urls.size())
|
|
{
|
|
cur_index = 0;
|
|
}
|
|
records[cur_index].clear();
|
|
} while (cur_index != first_index);
|
|
|
|
size_t num_valid_records = 0;
|
|
|
|
for( const auto& record_set : records)
|
|
{
|
|
if (record_set.size() != 0)
|
|
{
|
|
num_valid_records++;
|
|
}
|
|
}
|
|
|
|
if (num_valid_records < 2)
|
|
{
|
|
LOG_PRINT_L0("WARNING: no two valid MoneroPulse DNS checkpoint records were received");
|
|
return true;
|
|
}
|
|
|
|
int good_records_index = -1;
|
|
for (size_t i = 0; i < records.size() - 1; ++i)
|
|
{
|
|
if (records[i].size() == 0) continue;
|
|
|
|
for (size_t j = i + 1; j < records.size(); ++j)
|
|
{
|
|
if (dns_records_match(records[i], records[j]))
|
|
{
|
|
good_records_index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (good_records_index >= 0) break;
|
|
}
|
|
|
|
if (good_records_index < 0)
|
|
{
|
|
LOG_PRINT_L0("WARNING: no two MoneroPulse DNS checkpoint records matched");
|
|
return true;
|
|
}
|
|
|
|
for (auto& record : records[good_records_index])
|
|
{
|
|
auto pos = record.find(":");
|
|
if (pos != std::string::npos)
|
|
{
|
|
uint64_t height;
|
|
crypto::hash hash;
|
|
|
|
// parse the first part as uint64_t,
|
|
// if this fails move on to the next record
|
|
std::stringstream ss(record.substr(0, pos));
|
|
if (!(ss >> height))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// parse the second part as crypto::hash,
|
|
// if this fails move on to the next record
|
|
std::string hashStr = record.substr(pos + 1);
|
|
if (!epee::string_tools::parse_tpod_from_hex_string(hashStr, hash))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
ADD_CHECKPOINT(height, hashStr);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool checkpoints::load_new_checkpoints(const std::string json_hashfile_fullpath, bool testnet, bool dns)
|
|
{
|
|
bool result;
|
|
|
|
result = load_checkpoints_from_json(json_hashfile_fullpath);
|
|
if (dns)
|
|
{
|
|
result &= load_checkpoints_from_dns(testnet);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|