aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/blockchain_utilities/CMakeLists.txt4
-rw-r--r--src/blockchain_utilities/blockchain_blackball.cpp170
-rw-r--r--src/cryptonote_basic/hardfork.cpp18
-rw-r--r--src/cryptonote_core/blockchain.cpp22
-rw-r--r--src/cryptonote_core/blockchain.h7
-rw-r--r--src/cryptonote_core/cryptonote_core.cpp5
-rw-r--r--src/cryptonote_core/cryptonote_core.h7
-rw-r--r--src/cryptonote_protocol/cryptonote_protocol_handler.inl6
-rw-r--r--src/rpc/core_rpc_server.cpp20
-rw-r--r--src/wallet/api/wallet.cpp54
-rw-r--r--src/wallet/api/wallet.h3
-rw-r--r--src/wallet/api/wallet2_api.h21
-rw-r--r--src/wallet/wallet2.cpp38
-rw-r--r--src/wallet/wallet2.h16
14 files changed, 339 insertions, 52 deletions
diff --git a/src/blockchain_utilities/CMakeLists.txt b/src/blockchain_utilities/CMakeLists.txt
index a5dd69556..338ec3e4b 100644
--- a/src/blockchain_utilities/CMakeLists.txt
+++ b/src/blockchain_utilities/CMakeLists.txt
@@ -100,7 +100,6 @@ target_link_libraries(blockchain_import
PRIVATE
cryptonote_core
blockchain_db
- p2p
version
epee
${Boost_FILESYSTEM_LIBRARY}
@@ -127,7 +126,6 @@ target_link_libraries(blockchain_export
PRIVATE
cryptonote_core
blockchain_db
- p2p
version
epee
${Boost_FILESYSTEM_LIBRARY}
@@ -150,7 +148,6 @@ target_link_libraries(blockchain_blackball
wallet
cryptonote_core
blockchain_db
- p2p
version
epee
${Boost_FILESYSTEM_LIBRARY}
@@ -173,7 +170,6 @@ target_link_libraries(blockchain_usage
PRIVATE
cryptonote_core
blockchain_db
- p2p
version
epee
${Boost_FILESYSTEM_LIBRARY}
diff --git a/src/blockchain_utilities/blockchain_blackball.cpp b/src/blockchain_utilities/blockchain_blackball.cpp
index 1243822bb..95eb2f73d 100644
--- a/src/blockchain_utilities/blockchain_blackball.cpp
+++ b/src/blockchain_utilities/blockchain_blackball.cpp
@@ -28,8 +28,13 @@
#include <boost/range/adaptor/transformed.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/archive/portable_binary_iarchive.hpp>
+#include <boost/archive/portable_binary_oarchive.hpp>
+#include "common/unordered_containers_boost_serialization.h"
#include "common/command_line.h"
#include "common/varint.h"
+#include "serialization/crypto.h"
+#include "cryptonote_basic/cryptonote_boost_serialization.h"
#include "cryptonote_core/tx_pool.h"
#include "cryptonote_core/cryptonote_core.h"
#include "cryptonote_core/blockchain.h"
@@ -49,9 +54,17 @@ struct output_data
{
uint64_t amount;
uint64_t index;
+ output_data(): amount(0), index(0) {}
output_data(uint64_t a, uint64_t i): amount(a), index(i) {}
bool operator==(const output_data &other) const { return other.amount == amount && other.index == index; }
+ template <typename t_archive> void serialize(t_archive &a, const unsigned int ver)
+ {
+ a & amount;
+ a & index;
+ }
};
+BOOST_CLASS_VERSION(output_data, 0)
+
namespace std
{
template<> struct hash<output_data>
@@ -64,8 +77,38 @@ namespace std
return reinterpret_cast<const std::size_t &>(h);
}
};
+ template<> struct hash<std::vector<uint64_t>>
+ {
+ size_t operator()(const std::vector<uint64_t> &v) const
+ {
+ crypto::hash h;
+ crypto::cn_fast_hash(v.data(), v.size() * sizeof(uint64_t), h);
+ return reinterpret_cast<const std::size_t &>(h);
+ }
+ };
}
+struct blackball_state_t
+{
+ std::unordered_map<crypto::key_image, std::vector<uint64_t>> relative_rings;
+ std::unordered_map<output_data, std::unordered_set<crypto::key_image>> outputs;
+ std::unordered_map<std::string, uint64_t> processed_heights;
+ std::unordered_set<output_data> spent;
+ std::unordered_map<std::vector<uint64_t>, size_t> ring_instances;
+
+ template <typename t_archive> void serialize(t_archive &a, const unsigned int ver)
+ {
+ a & relative_rings;
+ a & outputs;
+ a & processed_heights;
+ a & spent;
+ if (ver < 1)
+ return;
+ a & ring_instances;
+ }
+};
+BOOST_CLASS_VERSION(blackball_state_t, 1)
+
static std::string get_default_db_path()
{
boost::filesystem::path dir = tools::get_default_data_dir();
@@ -75,7 +118,7 @@ static std::string get_default_db_path()
return dir.string();
}
-static bool for_all_transactions(const std::string &filename, const std::function<bool(const cryptonote::transaction_prefix&)> &f)
+static bool for_all_transactions(const std::string &filename, uint64_t &start_idx, const std::function<bool(const cryptonote::transaction_prefix&)> &f)
{
MDB_env *env;
MDB_dbi dbi;
@@ -109,7 +152,9 @@ static bool for_all_transactions(const std::string &filename, const std::functio
MDB_val v;
bool fret = true;
- MDB_cursor_op op = MDB_FIRST;
+ k.mv_size = sizeof(uint64_t);
+ k.mv_data = &start_idx;
+ MDB_cursor_op op = MDB_SET;
while (1)
{
int ret = mdb_cursor_get(cur, &k, &v, op);
@@ -119,6 +164,12 @@ static bool for_all_transactions(const std::string &filename, const std::functio
if (ret)
throw std::runtime_error("Failed to enumerate transactions: " + std::string(mdb_strerror(ret)));
+ if (k.mv_size != sizeof(uint64_t))
+ throw std::runtime_error("Bad key size");
+ const uint64_t idx = *(uint64_t*)k.mv_data;
+ if (idx < start_idx)
+ continue;
+
cryptonote::transaction_prefix tx;
blobdata bd;
bd.assign(reinterpret_cast<char*>(v.mv_data), v.mv_size);
@@ -128,6 +179,7 @@ static bool for_all_transactions(const std::string &filename, const std::functio
bool r = do_serialize(ba, tx);
CHECK_AND_ASSERT_MES(r, false, "Failed to parse transaction from blob");
+ start_idx = *(uint64_t*)k.mv_data;
if (!f(tx)) {
fret = false;
break;
@@ -142,6 +194,24 @@ static bool for_all_transactions(const std::string &filename, const std::functio
return fret;
}
+static std::vector<uint64_t> canonicalize(const std::vector<uint64_t> &v)
+{
+ std::vector<uint64_t> c;
+ c.reserve(v.size());
+ c.push_back(v[0]);
+ for (size_t n = 1; n < v.size(); ++n)
+ {
+ if (v[n] != 0)
+ c.push_back(v[n]);
+ }
+ if (c.size() < v.size())
+ {
+ MINFO("Ring has duplicate member(s): " <<
+ boost::join(v | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " "));
+ }
+ return c;
+}
+
int main(int argc, char* argv[])
{
TRY_ENTRY();
@@ -308,17 +378,41 @@ int main(int argc, char* argv[])
LOG_PRINT_L0("Scanning for blackballable outputs...");
size_t done = 0;
- std::unordered_map<crypto::key_image, std::vector<uint64_t>> relative_rings;
- std::unordered_map<output_data, std::unordered_set<crypto::key_image>> outputs;
- std::unordered_set<output_data> spent, newly_spent;
+ blackball_state_t state;
+ std::unordered_set<output_data> newly_spent;
+ const std::string state_file_path = (boost::filesystem::path(output_file_path) / "blackball-state.bin").string();
+
+ LOG_PRINT_L0("Loading state data from " << state_file_path);
+ std::ifstream state_data_in;
+ state_data_in.open(state_file_path, std::ios_base::binary | std::ios_base::in);
+ if (!state_data_in.fail())
+ {
+ try
+ {
+ boost::archive::portable_binary_iarchive a(state_data_in);
+ a >> state;
+ }
+ catch (const std::exception &e)
+ {
+ MERROR("Failed to load state data from " << state_file_path << ", restarting from scratch");
+ state = blackball_state_t();
+ }
+ state_data_in.close();
+ }
+ uint64_t start_blackballed_outputs = state.spent.size();
cryptonote::block b = core_storage[0]->get_db().get_block_from_height(0);
tools::ringdb ringdb(output_file_path.string(), epee::string_tools::pod_to_hex(get_block_hash(b)));
for (size_t n = 0; n < inputs.size(); ++n)
{
- LOG_PRINT_L0("Reading blockchain from " << inputs[n]);
- for_all_transactions(inputs[n], [&](const cryptonote::transaction_prefix &tx)->bool
+ const std::string canonical = boost::filesystem::canonical(inputs[n]).string();
+ uint64_t start_idx = 0;
+ auto it = state.processed_heights.find(canonical);
+ if (it != state.processed_heights.end())
+ start_idx = it->second;
+ LOG_PRINT_L0("Reading blockchain from " << inputs[n] << " from " << start_idx);
+ for_all_transactions(inputs[n], start_idx, [&](const cryptonote::transaction_prefix &tx)->bool
{
for (const auto &in: tx.vin)
{
@@ -331,27 +425,39 @@ int main(int argc, char* argv[])
const std::vector<uint64_t> absolute = cryptonote::relative_output_offsets_to_absolute(txin.key_offsets);
if (n == 0)
for (uint64_t out: absolute)
- outputs[output_data(txin.amount, out)].insert(txin.k_image);
+ state.outputs[output_data(txin.amount, out)].insert(txin.k_image);
- std::vector<uint64_t> new_ring = txin.key_offsets;
+ std::vector<uint64_t> new_ring = canonicalize(txin.key_offsets);
const uint32_t ring_size = txin.key_offsets.size();
+ state.ring_instances[new_ring] += 1;
if (ring_size == 1)
{
- const crypto::public_key pkey = core_storage[n]->get_output_key(txin.amount, txin.key_offsets[0]);
+ const crypto::public_key pkey = core_storage[n]->get_output_key(txin.amount, absolute[0]);
MINFO("Blackballing output " << pkey << ", due to being used in a 1-ring");
ringdb.blackball(pkey);
- newly_spent.insert(output_data(txin.amount, txin.key_offsets[0]));
- spent.insert(output_data(txin.amount, txin.key_offsets[0]));
+ newly_spent.insert(output_data(txin.amount, absolute[0]));
+ state.spent.insert(output_data(txin.amount, absolute[0]));
}
- else if (relative_rings.find(txin.k_image) != relative_rings.end())
+ else if (state.ring_instances[new_ring] == new_ring.size())
+ {
+ for (size_t o = 0; o < new_ring.size(); ++o)
+ {
+ const crypto::public_key pkey = core_storage[n]->get_output_key(txin.amount, absolute[o]);
+ MINFO("Blackballing output " << pkey << ", due to being used in " << new_ring.size() << " identical " << new_ring.size() << "-rings");
+ ringdb.blackball(pkey);
+ newly_spent.insert(output_data(txin.amount, absolute[o]));
+ state.spent.insert(output_data(txin.amount, absolute[o]));
+ }
+ }
+ else if (state.relative_rings.find(txin.k_image) != state.relative_rings.end())
{
MINFO("Key image " << txin.k_image << " already seen: rings " <<
- boost::join(relative_rings[txin.k_image] | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " ") <<
+ boost::join(state.relative_rings[txin.k_image] | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " ") <<
", " << boost::join(txin.key_offsets | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " "));
- if (relative_rings[txin.k_image] != txin.key_offsets)
+ if (state.relative_rings[txin.k_image] != txin.key_offsets)
{
MINFO("Rings are different");
- const std::vector<uint64_t> r0 = cryptonote::relative_output_offsets_to_absolute(relative_rings[txin.k_image]);
+ const std::vector<uint64_t> r0 = cryptonote::relative_output_offsets_to_absolute(state.relative_rings[txin.k_image]);
const std::vector<uint64_t> r1 = cryptonote::relative_output_offsets_to_absolute(txin.key_offsets);
std::vector<uint64_t> common;
for (uint64_t out: r0)
@@ -369,7 +475,7 @@ int main(int argc, char* argv[])
MINFO("Blackballing output " << pkey << ", due to being used in rings with a single common element");
ringdb.blackball(pkey);
newly_spent.insert(output_data(txin.amount, common[0]));
- spent.insert(output_data(txin.amount, common[0]));
+ state.spent.insert(output_data(txin.amount, common[0]));
}
else
{
@@ -381,10 +487,11 @@ int main(int argc, char* argv[])
}
}
}
- relative_rings[txin.k_image] = new_ring;
+ state.relative_rings[txin.k_image] = new_ring;
}
return true;
});
+ state.processed_heights[canonical] = start_idx;
}
while (!newly_spent.empty())
@@ -395,15 +502,15 @@ int main(int argc, char* argv[])
for (const output_data &od: work_spent)
{
- for (const crypto::key_image &ki: outputs[od])
+ for (const crypto::key_image &ki: state.outputs[od])
{
- std::vector<uint64_t> absolute = cryptonote::relative_output_offsets_to_absolute(relative_rings[ki]);
+ std::vector<uint64_t> absolute = cryptonote::relative_output_offsets_to_absolute(state.relative_rings[ki]);
size_t known = 0;
uint64_t last_unknown = 0;
for (uint64_t out: absolute)
{
output_data new_od(od.amount, out);
- if (spent.find(new_od) != spent.end())
+ if (state.spent.find(new_od) != state.spent.end())
++known;
else
last_unknown = out;
@@ -415,12 +522,31 @@ int main(int argc, char* argv[])
absolute.size() << "-ring where all other outputs are known to be spent");
ringdb.blackball(pkey);
newly_spent.insert(output_data(od.amount, last_unknown));
- spent.insert(output_data(od.amount, last_unknown));
+ state.spent.insert(output_data(od.amount, last_unknown));
}
}
}
}
+ LOG_PRINT_L0("Saving state data to " << state_file_path);
+ std::ofstream state_data_out;
+ state_data_out.open(state_file_path, std::ios_base::binary | std::ios_base::out | std::ios::trunc);
+ if (!state_data_out.fail())
+ {
+ try
+ {
+ boost::archive::portable_binary_oarchive a(state_data_out);
+ a << state;
+ }
+ catch (const std::exception &e)
+ {
+ MERROR("Failed to save state data to " << state_file_path);
+ }
+ state_data_out.close();
+ }
+
+ uint64_t diff = state.spent.size() - start_blackballed_outputs;
+ LOG_PRINT_L0(std::to_string(diff) << " new outputs blackballed, " << state.spent.size() << " total outputs blackballed");
LOG_PRINT_L0("Blockchain blackball data exported OK");
return 0;
diff --git a/src/cryptonote_basic/hardfork.cpp b/src/cryptonote_basic/hardfork.cpp
index 95f1ecab9..f05b25901 100644
--- a/src/cryptonote_basic/hardfork.cpp
+++ b/src/cryptonote_basic/hardfork.cpp
@@ -379,20 +379,24 @@ uint8_t HardFork::get_ideal_version(uint64_t height) const
uint64_t HardFork::get_earliest_ideal_height_for_version(uint8_t version) const
{
- for (unsigned int n = heights.size() - 1; n > 0; --n) {
- if (heights[n].version <= version)
- return heights[n].height;
+ uint64_t height = std::numeric_limits<uint64_t>::max();
+ for (auto i = heights.rbegin(); i != heights.rend(); ++i) {
+ if (i->version >= version) {
+ height = i->height;
+ } else {
+ break;
+ }
}
- return 0;
+ return height;
}
uint8_t HardFork::get_next_version() const
{
CRITICAL_REGION_LOCAL(lock);
uint64_t height = db.height();
- for (unsigned int n = heights.size() - 1; n > 0; --n) {
- if (height >= heights[n].height) {
- return heights[n < heights.size() - 1 ? n + 1 : n].version;
+ for (auto i = heights.rbegin(); i != heights.rend(); ++i) {
+ if (height >= i->height) {
+ return (i == heights.rbegin() ? i : (i - 1))->version;
}
}
return original_version;
diff --git a/src/cryptonote_core/blockchain.cpp b/src/cryptonote_core/blockchain.cpp
index 08184fc40..fbb2a2223 100644
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@@ -807,16 +807,18 @@ difficulty_type Blockchain::get_difficulty_for_next_block()
{
LOG_PRINT_L3("Blockchain::" << __func__);
- CRITICAL_REGION_LOCAL(m_difficulty_lock);
- // we can call this without the blockchain lock, it might just give us
- // something a bit out of date, but that's fine since anything which
- // requires the blockchain lock will have acquired it in the first place,
- // and it will be unlocked only when called from the getinfo RPC
crypto::hash top_hash = get_tail_id();
- if (top_hash == m_difficulty_for_next_block_top_hash)
- return m_difficulty_for_next_block;
+ {
+ CRITICAL_REGION_LOCAL(m_difficulty_lock);
+ // we can call this without the blockchain lock, it might just give us
+ // something a bit out of date, but that's fine since anything which
+ // requires the blockchain lock will have acquired it in the first place,
+ // and it will be unlocked only when called from the getinfo RPC
+ if (top_hash == m_difficulty_for_next_block_top_hash)
+ return m_difficulty_for_next_block;
+ }
- CRITICAL_REGION_LOCAL1(m_blockchain_lock);
+ CRITICAL_REGION_LOCAL(m_blockchain_lock);
std::vector<uint64_t> timestamps;
std::vector<difficulty_type> difficulties;
auto height = m_db->height();
@@ -860,6 +862,8 @@ difficulty_type Blockchain::get_difficulty_for_next_block()
}
size_t target = get_difficulty_target();
difficulty_type diff = next_difficulty(timestamps, difficulties, target);
+
+ CRITICAL_REGION_LOCAL1(m_difficulty_lock);
m_difficulty_for_next_block_top_hash = top_hash;
m_difficulty_for_next_block = diff;
return diff;
@@ -3929,7 +3933,7 @@ uint64_t Blockchain::prevalidate_block_hashes(uint64_t height, const std::list<c
// add to the known hashes array
if (!valid)
{
- MWARNING("invalid hash for blocks " << n * HASH_OF_HASHES_STEP << " - " << (n * HASH_OF_HASHES_STEP + HASH_OF_HASHES_STEP - 1));
+ MDEBUG("invalid hash for blocks " << n * HASH_OF_HASHES_STEP << " - " << (n * HASH_OF_HASHES_STEP + HASH_OF_HASHES_STEP - 1));
break;
}
diff --git a/src/cryptonote_core/blockchain.h b/src/cryptonote_core/blockchain.h
index 769e608ca..ef736d1e7 100644
--- a/src/cryptonote_core/blockchain.h
+++ b/src/cryptonote_core/blockchain.h
@@ -795,6 +795,13 @@ namespace cryptonote
uint8_t get_hard_fork_version(uint64_t height) const { return m_hardfork->get(height); }
/**
+ * @brief returns the earliest block a given version may activate
+ *
+ * @return the height
+ */
+ uint64_t get_earliest_ideal_height_for_version(uint8_t version) const { return m_hardfork->get_earliest_ideal_height_for_version(version); }
+
+ /**
* @brief get information about hardfork voting for a version
*
* @param version the version in question
diff --git a/src/cryptonote_core/cryptonote_core.cpp b/src/cryptonote_core/cryptonote_core.cpp
index d2796deeb..7d34415c4 100644
--- a/src/cryptonote_core/cryptonote_core.cpp
+++ b/src/cryptonote_core/cryptonote_core.cpp
@@ -1401,6 +1401,11 @@ namespace cryptonote
return get_blockchain_storage().get_hard_fork_version(height);
}
//-----------------------------------------------------------------------------------------------
+ uint64_t core::get_earliest_ideal_height_for_version(uint8_t version) const
+ {
+ return get_blockchain_storage().get_earliest_ideal_height_for_version(version);
+ }
+ //-----------------------------------------------------------------------------------------------
bool core::check_updates()
{
static const char software[] = "monero";
diff --git a/src/cryptonote_core/cryptonote_core.h b/src/cryptonote_core/cryptonote_core.h
index 17b5680e5..567966d48 100644
--- a/src/cryptonote_core/cryptonote_core.h
+++ b/src/cryptonote_core/cryptonote_core.h
@@ -663,6 +663,13 @@ namespace cryptonote
uint8_t get_hard_fork_version(uint64_t height) const;
/**
+ * @brief return the earliest block a given version may activate
+ *
+ * @return what it says above
+ */
+ uint64_t get_earliest_ideal_height_for_version(uint8_t version) const;
+
+ /**
* @brief gets start_time
*
*/
diff --git a/src/cryptonote_protocol/cryptonote_protocol_handler.inl b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
index 91c6c5d5e..2e1df8078 100644
--- a/src/cryptonote_protocol/cryptonote_protocol_handler.inl
+++ b/src/cryptonote_protocol/cryptonote_protocol_handler.inl
@@ -1630,10 +1630,10 @@ skip:
}
uint64_t n_use_blocks = m_core.prevalidate_block_hashes(arg.start_height, arg.m_block_ids);
- if (n_use_blocks == 0)
+ if (n_use_blocks + HASH_OF_HASHES_STEP <= arg.m_block_ids.size())
{
- LOG_ERROR_CCONTEXT("Peer yielded no usable blocks, dropping connection");
- drop_connection(context, false, false);
+ LOG_ERROR_CCONTEXT("Most blocks are invalid, dropping connection");
+ drop_connection(context, true, false);
return 1;
}
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index aa105567c..dc7b6b30f 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -2087,6 +2087,13 @@ namespace cryptonote
if (d.cached && amount == 0 && d.cached_from == req.from_height && d.cached_to == req.to_height)
{
res.distributions.push_back({amount, d.cached_start_height, d.cached_distribution, d.cached_base});
+ if (req.cumulative)
+ {
+ auto &distribution = res.distributions.back().distribution;
+ distribution[0] += d.cached_base;
+ for (size_t n = 1; n < distribution.size(); ++n)
+ distribution[n] += distribution[n-1];
+ }
continue;
}
@@ -2125,12 +2132,6 @@ namespace cryptonote
if (offset <= req.to_height && req.to_height - offset + 1 < distribution.size())
distribution.resize(req.to_height - offset + 1);
}
- if (req.cumulative)
- {
- distribution[0] += base;
- for (size_t n = 1; n < distribution.size(); ++n)
- distribution[n] += distribution[n-1];
- }
if (amount == 0)
{
@@ -2142,6 +2143,13 @@ namespace cryptonote
d.cached = true;
}
+ if (req.cumulative)
+ {
+ distribution[0] += base;
+ for (size_t n = 1; n < distribution.size(); ++n)
+ distribution[n] += distribution[n-1];
+ }
+
res.distributions.push_back({amount, start_height, std::move(distribution), base});
}
}
diff --git a/src/wallet/api/wallet.cpp b/src/wallet/api/wallet.cpp
index fdecacd8f..908e2db2e 100644
--- a/src/wallet/api/wallet.cpp
+++ b/src/wallet/api/wallet.cpp
@@ -778,6 +778,16 @@ std::string WalletImpl::publicSpendKey() const
return epee::string_tools::pod_to_hex(m_wallet->get_account().get_keys().m_account_address.m_spend_public_key);
}
+std::string WalletImpl::publicMultisigSignerKey() const
+{
+ try {
+ crypto::public_key signer = m_wallet->get_multisig_signer_public_key();
+ return epee::string_tools::pod_to_hex(signer);
+ } catch (const std::exception&) {
+ return "";
+ }
+}
+
std::string WalletImpl::path() const
{
return m_wallet->path();
@@ -1766,6 +1776,50 @@ bool WalletImpl::verifySignedMessage(const std::string &message, const std::stri
return m_wallet->verify(message, info.address, signature);
}
+std::string WalletImpl::signMultisigParticipant(const std::string &message) const
+{
+ clearStatus();
+
+ bool ready = false;
+ if (!m_wallet->multisig(&ready) || !ready) {
+ m_status = Status_Error;
+ m_errorString = tr("The wallet must be in multisig ready state");
+ return {};
+ }
+
+ try {
+ return m_wallet->sign_multisig_participant(message);
+ } catch (const std::exception& e) {
+ m_status = Status_Error;
+ m_errorString = e.what();
+ }
+
+ return {};
+}
+
+bool WalletImpl::verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const
+{
+ clearStatus();
+
+ cryptonote::blobdata pkeyData;
+ if(!epee::string_tools::parse_hexstr_to_binbuff(publicKey, pkeyData) || pkeyData.size() != sizeof(crypto::public_key))
+ {
+ m_status = Status_Error;
+ m_errorString = tr("Given string is not a key");
+ return false;
+ }
+
+ try {
+ crypto::public_key pkey = *reinterpret_cast<const crypto::public_key*>(pkeyData.data());
+ return m_wallet->verify_with_public_key(message, pkey, signature);
+ } catch (const std::exception& e) {
+ m_status = Status_Error;
+ m_errorString = e.what();
+ }
+
+ return false;
+}
+
bool WalletImpl::connectToDaemon()
{
bool result = m_wallet->check_connection(NULL, DEFAULT_CONNECTION_TIMEOUT_MILLIS);
diff --git a/src/wallet/api/wallet.h b/src/wallet/api/wallet.h
index e0e627c36..813ca4b30 100644
--- a/src/wallet/api/wallet.h
+++ b/src/wallet/api/wallet.h
@@ -91,6 +91,7 @@ public:
std::string publicViewKey() const;
std::string secretSpendKey() const;
std::string publicSpendKey() const;
+ std::string publicMultisigSignerKey() const;
std::string path() const;
bool store(const std::string &path);
std::string filename() const;
@@ -166,6 +167,8 @@ public:
virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const;
virtual std::string signMessage(const std::string &message);
virtual bool verifySignedMessage(const std::string &message, const std::string &address, const std::string &signature) const;
+ virtual std::string signMultisigParticipant(const std::string &message) const;
+ virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const;
virtual void startRefresh();
virtual void pauseRefresh();
virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error);
diff --git a/src/wallet/api/wallet2_api.h b/src/wallet/api/wallet2_api.h
index 27d290e68..5b99bd975 100644
--- a/src/wallet/api/wallet2_api.h
+++ b/src/wallet/api/wallet2_api.h
@@ -444,6 +444,12 @@ struct Wallet
virtual std::string publicSpendKey() const = 0;
/*!
+ * \brief publicMultisigSignerKey - returns public signer key
+ * \return - public multisignature signer key or empty string if wallet is not multisig
+ */
+ virtual std::string publicMultisigSignerKey() const = 0;
+
+ /*!
* \brief store - stores wallet to file.
* \param path - main filename to store wallet to. additionally stores address file and keys file.
* to store to the same file - just pass empty string;
@@ -825,6 +831,21 @@ struct Wallet
*/
virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0;
+ /*!
+ * \brief signMultisigParticipant signs given message with the multisig public signer key
+ * \param message message to sign
+ * \return signature in case of success. Sets status to Error and return empty string in case of error
+ */
+ virtual std::string signMultisigParticipant(const std::string &message) const = 0;
+ /*!
+ * \brief verifyMessageWithPublicKey verifies that message was signed with the given public key
+ * \param message message
+ * \param publicKey hex encoded public key
+ * \param signature signature of the message
+ * \return true if the signature is correct. false and sets error state in case of error
+ */
+ virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0;
+
virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error) = 0;
virtual std::string getDefaultDataDir() const = 0;
diff --git a/src/wallet/wallet2.cpp b/src/wallet/wallet2.cpp
index 3af449455..d2db45f12 100644
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@@ -115,6 +115,8 @@ using namespace cryptonote;
#define STAGENET_SEGREGATION_FORK_HEIGHT 1000000
#define SEGREGATION_FORK_VICINITY 1500 /* blocks */
+static const std::string MULTISIG_SIGNATURE_MAGIC = "SigMultisigPkV1";
+
namespace
{
@@ -5672,7 +5674,7 @@ bool wallet2::find_and_save_rings(bool force)
for (size_t slice = 0; slice < txs_hashes.size(); slice += SLICE_SIZE)
{
req.decode_as_json = false;
- req.prune = true;
+ req.prune = false;
req.txs_hashes.clear();
size_t ntxes = slice + SLICE_SIZE > txs_hashes.size() ? txs_hashes.size() - slice : SLICE_SIZE;
for (size_t s = slice; s < slice + ntxes; ++s)
@@ -9282,6 +9284,40 @@ bool wallet2::verify(const std::string &data, const cryptonote::account_public_a
memcpy(&s, decoded.data(), sizeof(s));
return crypto::check_signature(hash, address.m_spend_public_key, s);
}
+
+std::string wallet2::sign_multisig_participant(const std::string& data) const
+{
+ CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
+
+ crypto::hash hash;
+ crypto::cn_fast_hash(data.data(), data.size(), hash);
+ const cryptonote::account_keys &keys = m_account.get_keys();
+ crypto::signature signature;
+ crypto::generate_signature(hash, get_multisig_signer_public_key(), keys.m_spend_secret_key, signature);
+ return MULTISIG_SIGNATURE_MAGIC + tools::base58::encode(std::string((const char *)&signature, sizeof(signature)));
+}
+
+bool wallet2::verify_with_public_key(const std::string &data, const crypto::public_key &public_key, const std::string &signature) const
+{
+ if (signature.size() < MULTISIG_SIGNATURE_MAGIC.size() || signature.substr(0, MULTISIG_SIGNATURE_MAGIC.size()) != MULTISIG_SIGNATURE_MAGIC) {
+ MERROR("Signature header check error");
+ return false;
+ }
+ crypto::hash hash;
+ crypto::cn_fast_hash(data.data(), data.size(), hash);
+ std::string decoded;
+ if (!tools::base58::decode(signature.substr(MULTISIG_SIGNATURE_MAGIC.size()), decoded)) {
+ MERROR("Signature decoding error");
+ return false;
+ }
+ crypto::signature s;
+ if (sizeof(s) != decoded.size()) {
+ MERROR("Signature decoding error");
+ return false;
+ }
+ memcpy(&s, decoded.data(), sizeof(s));
+ return crypto::check_signature(hash, public_key, s);
+}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_tx_pub_key_from_received_outs(const tools::wallet2::transfer_details &td) const
{
diff --git a/src/wallet/wallet2.h b/src/wallet/wallet2.h
index 5e0dd076b..40f6e08d9 100644
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@@ -969,6 +969,22 @@ namespace tools
std::string sign(const std::string &data) const;
bool verify(const std::string &data, const cryptonote::account_public_address &address, const std::string &signature) const;
+ /*!
+ * \brief sign_multisig_participant signs given message with the multisig public signer key
+ * \param data message to sign
+ * \throws if wallet is not multisig
+ * \return signature
+ */
+ std::string sign_multisig_participant(const std::string& data) const;
+ /*!
+ * \brief verify_with_public_key verifies message was signed with given public key
+ * \param data message
+ * \param public_key public key to check signature
+ * \param signature signature of the message
+ * \return true if the signature is correct
+ */
+ bool verify_with_public_key(const std::string &data, const crypto::public_key &public_key, const std::string &signature) const;
+
// Import/Export wallet data
std::vector<tools::wallet2::transfer_details> export_outputs() const;
size_t import_outputs(const std::vector<tools::wallet2::transfer_details> &outputs);