dn724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Clearing private and secret keys with RAII.

Browse source
This commit is contained in:
clemahieu 2015-11-06 15:11:52 -06:00
commit b0471c78ee
25 changed files with 377 additions and 273 deletions
Download patch file Download diff file Expand all files Collapse all files

28
rai/core_test/block.cpp
View file

@ -35,7 +35,7 @@ TEST (transaction_block, empty)
TEST (block, send_serialize)
{
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
std::vector <uint8_t> bytes;
{
rai::vectorstream stream1 (bytes);
@ -54,7 +54,7 @@ TEST (block, send_serialize)
TEST (block, send_serialize_json)
{
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
std::string string1;
block1.serialize_json (string1);
ASSERT_NE (0, string1.size ());
@ -69,7 +69,7 @@ TEST (block, send_serialize_json)
TEST (block, receive_serialize)
{
rai::receive_block block1 (0, 1, 2, 3, 4);
rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4);
rai::keypair key1;
std::vector <uint8_t> bytes;
{
@ -85,7 +85,7 @@ TEST (block, receive_serialize)
TEST (block, receive_serialize_json)
{
rai::receive_block block1 (0, 1, 2, 3, 4);
rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4);
std::string string1;
block1.serialize_json (string1);
ASSERT_NE (0, string1.size ());
@ -100,7 +100,7 @@ TEST (block, receive_serialize_json)
TEST (block, open_serialize_json)
{
rai::open_block block1 (0, 1, 0, 0, 0, 0);
rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0);
std::string string1;
block1.serialize_json (string1);
ASSERT_NE (0, string1.size ());
@ -115,7 +115,7 @@ TEST (block, open_serialize_json)
TEST (block, change_serialize_json)
{
rai::change_block block1 (0, 1, 2, 3, 4);
rai::change_block block1 (0, 1, rai::keypair ().prv, 3, 4);
std::string string1;
block1.serialize_json (string1);
ASSERT_NE (0, string1.size ());
@ -197,7 +197,7 @@ TEST (uint512_union, parse_error_overflow)
TEST (send_block, deserialize)
{
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes;
{
@ -214,7 +214,7 @@ TEST (send_block, deserialize)
TEST (receive_block, deserialize)
{
rai::receive_block block1 (0, 1, 2, 3, 4);
rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4);
ASSERT_EQ (block1.hash (), block1.hash ());
block1.hashables.previous = 2;
block1.hashables.source = 4;
@ -233,7 +233,7 @@ TEST (receive_block, deserialize)
TEST (open_block, deserialize)
{
rai::open_block block1 (0, 1, 0, 0, 0, 0);
rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0);
ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes;
{
@ -250,7 +250,7 @@ TEST (open_block, deserialize)
TEST (change_block, deserialize)
{
rai::change_block block1 (1, 2, 3, 4, 5);
rai::change_block block1 (1, 2, rai::keypair ().prv, 4, 5);
ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes;
{
@ -289,7 +289,7 @@ TEST (frontier_req, serialization)
TEST (work, one)
{
rai::work_pool pool;
rai::change_block block (1, 1, 2, 3, 4);
rai::change_block block (1, 1, rai::keypair ().prv, 3, 4);
pool.generate (block);
ASSERT_FALSE (pool.work_validate (block));
}
@ -297,7 +297,7 @@ TEST (work, one)
TEST (work, validate)
{
rai::work_pool pool;
rai::send_block send_block (1, 1, 2, 3, 4, 6);
rai::send_block send_block (1, 1, 2, rai::keypair ().prv, 4, 6);
ASSERT_TRUE (pool.work_validate (send_block));
pool.generate (send_block);
ASSERT_FALSE (pool.work_validate (send_block));
@ -307,7 +307,7 @@ TEST (block, publish_req_serialization)
{
rai::keypair key1;
rai::keypair key2;
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (0, key2.pub, 200, 1, 2, 3)));
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (0, key2.pub, 200, rai::keypair ().prv, 2, 3)));
rai::publish req (std::move (block));
std::vector <uint8_t> bytes;
{
@ -326,7 +326,7 @@ TEST (block, confirm_req_serialization)
{
rai::keypair key1;
rai::keypair key2;
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (0, key2.pub, 200, 1, 2, 3)));
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (0, key2.pub, 200, rai::keypair ().prv, 2, 3)));
rai::confirm_req req (std::move (block));
std::vector <uint8_t> bytes;
{

36
rai/core_test/block_store.cpp
View file

@ -17,7 +17,7 @@ TEST (block_store, add_item)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::open_block block (0, 1, 0, 0, 0, 0);
rai::open_block block (0, 1, 0, rai::keypair ().prv, 0, 0);
rai::uint256_union hash1 (block.hash ());
rai::transaction transaction (store.environment, nullptr, true);
auto latest1 (store.block_get (transaction, hash1));
@ -40,7 +40,7 @@ TEST (block_store, add_nonempty_block)
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::keypair key1;
rai::open_block block (0, 1, 0, 0, 0, 0);
rai::open_block block (0, 1, 0, rai::keypair ().prv, 0, 0);
rai::uint256_union hash1 (block.hash ());
block.signature = rai::sign_message (key1.prv, key1.pub, hash1);
rai::transaction transaction (store.environment, nullptr, true);
@ -58,13 +58,13 @@ TEST (block_store, add_two_items)
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::keypair key1;
rai::open_block block (0, 1, 1, 0, 0, 0);
rai::open_block block (0, 1, 1, rai::keypair ().prv, 0, 0);
rai::uint256_union hash1 (block.hash ());
block.signature = rai::sign_message (key1.prv, key1.pub, hash1);
rai::transaction transaction (store.environment, nullptr, true);
auto latest1 (store.block_get (transaction, hash1));
ASSERT_EQ (nullptr, latest1);
rai::open_block block2 (0, 1, 3, 0, 0, 0);
rai::open_block block2 (0, 1, 3, rai::keypair ().prv, 0, 0);
block2.hashables.account = 3;
rai::uint256_union hash2 (block2.hash ());
block2.signature = rai::sign_message (key1.prv, key1.pub, hash2);
@ -88,10 +88,10 @@ TEST (block_store, add_receive)
ASSERT_TRUE (!init);
rai::keypair key1;
rai::keypair key2;
rai::open_block block1 (0, 1, 0, 0, 0, 0);
rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0);
rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, block1.hash (), block1);
rai::receive_block block (block1.hash (), 1, 1, 2, 3);
rai::receive_block block (block1.hash (), 1, rai::keypair ().prv, 2, 3);
rai::block_hash hash1 (block.hash ());
auto latest1 (store.block_get (transaction, hash1));
ASSERT_EQ (nullptr, latest1);
@ -155,7 +155,7 @@ TEST (block_store, genesis)
ASSERT_LE (info.modified, store.now ());
auto test_pub_text (rai::test_genesis_key.pub.to_string ());
auto test_pub_account (rai::test_genesis_key.pub.to_base58check ());
auto test_prv_text (rai::test_genesis_key.prv.to_string ());
auto test_prv_text (rai::test_genesis_key.prv.data.to_string ());
ASSERT_EQ (rai::genesis_account, rai::test_genesis_key.pub);
}
@ -178,7 +178,7 @@ TEST (bootstrap, simple)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::transaction transaction (store.environment, nullptr, true);
auto block2 (store.unchecked_get (transaction, block1.previous ()));
ASSERT_EQ (nullptr, block2);
@ -225,7 +225,7 @@ TEST (block_store, one_block)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::open_block block1 (0, 1, 0, 0, 0, 0);
rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0);
rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, block1.hash (), block1);
ASSERT_TRUE (store.block_exists (transaction, block1.hash ()));
@ -247,7 +247,7 @@ TEST (block_store, one_bootstrap)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::transaction transaction (store.environment, nullptr, true);
store.unchecked_put (transaction, block1.hash (), block1);
auto begin (store.unchecked_begin (transaction));
@ -301,7 +301,7 @@ TEST (block_store, two_block)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::open_block block1 (0, 1, 1, 0, 0, 0);
rai::open_block block1 (0, 1, 1, rai::keypair ().prv, 0, 0);
block1.hashables.account = 1;
std::vector <rai::block_hash> hashes;
std::vector <rai::open_block> blocks;
@ -309,7 +309,7 @@ TEST (block_store, two_block)
blocks.push_back (block1);
rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, hashes [0], block1);
rai::open_block block2 (0, 1, 2, 0, 0, 0);
rai::open_block block2 (0, 1, 2, rai::keypair ().prv, 0, 0);
hashes.push_back (block2.hash ());
blocks.push_back (block2);
store.block_put (transaction, hashes [1], block2);
@ -395,13 +395,13 @@ TEST (block_store, roots)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::send_block send_block (0, 1, 2, 3, 4, 5);
rai::send_block send_block (0, 1, 2, rai::keypair ().prv, 4, 5);
ASSERT_EQ (send_block.hashables.previous, send_block.root ());
rai::change_block change_block (0, 1, 2, 3, 4);
rai::change_block change_block (0, 1, rai::keypair ().prv, 3, 4);
ASSERT_EQ (change_block.hashables.previous, change_block.root ());
rai::receive_block receive_block (0, 1, 2, 3, 4);
rai::receive_block receive_block (0, 1, rai::keypair ().prv, 3, 4);
ASSERT_EQ (receive_block.hashables.previous, receive_block.root ());
rai::open_block open_block (0, 1, 2, 3, 4, 5);
rai::open_block open_block (0, 1, 2, rai::keypair ().prv, 4, 5);
ASSERT_EQ (open_block.hashables.account, open_block.root ());
}
@ -532,8 +532,8 @@ TEST (block_store, block_replace)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::send_block send1 (0, 0, 0, 0, 0, 1);
rai::send_block send2 (0, 0, 0, 0, 0, 2);
rai::send_block send1 (0, 0, 0, rai::keypair ().prv, 0, 1);
rai::send_block send2 (0, 0, 0, rai::keypair ().prv, 0, 2);
rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, 0, send1);
store.block_put (transaction, 0, send2);

50
rai/core_test/block_synchronization.cpp
View file

@ -22,8 +22,8 @@ TEST (pull_synchronization, one)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -44,9 +44,9 @@ TEST (pull_synchronization, send_dependencies)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::send_block block3 (block2.hash (), 0, 1, 2, 3, 4);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::send_block block3 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -71,9 +71,9 @@ TEST (pull_synchronization, change_dependencies)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::change_block block3 (block2.hash (), 0, 1, 2, 3);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::change_block block3 (block2.hash (), 0, rai::keypair ().prv, 2, 3);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -98,9 +98,9 @@ TEST (pull_synchronization, open_dependencies)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -125,11 +125,11 @@ TEST (pull_synchronization, receive_dependencies)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5);
rai::send_block block4 (block2.hash (), 0, 1, 2, 3, 4);
rai::receive_block block5 (block3.hash (), block4.hash (), 0, 0, 0);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
rai::send_block block4 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block5 (block3.hash (), block4.hash (), rai::keypair ().prv, 0, 0);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -158,13 +158,13 @@ TEST (pull_synchronization, ladder_dependencies)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5);
rai::send_block block4 (block3.hash (), 0, 1, 2, 3, 4);
rai::receive_block block5 (block2.hash (), block4.hash (), 0, 0, 0);
rai::send_block block6 (block5.hash (), 0, 1, 2, 3, 4);
rai::receive_block block7 (block4.hash (), block6.hash (), 0, 0, 0);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
rai::send_block block4 (block3.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block5 (block2.hash (), block4.hash (), rai::keypair ().prv, 0, 0);
rai::send_block block6 (block5.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block7 (block4.hash (), block6.hash (), rai::keypair ().prv, 0, 0);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);
@ -211,8 +211,8 @@ TEST (push_synchronization, one)
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4);
rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks;
{
rai::transaction transaction (store.environment, nullptr, true);

10
rai/core_test/gap_cache.cpp
View file

@ -5,7 +5,7 @@ TEST (gap_cache, add_new)
{
rai::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]);
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
cache.add (rai::send_block (block1), block1.previous ());
ASSERT_NE (cache.blocks.end (), cache.blocks.find (block1.previous ()));
}
@ -14,7 +14,7 @@ TEST (gap_cache, add_existing)
{
rai::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]);
rai::send_block block1 (0, 1, 2, 3, 4, 5);
rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
auto previous (block1.previous ());
cache.add (block1, previous);
auto existing1 (cache.blocks.find (previous));
@ -32,14 +32,14 @@ TEST (gap_cache, comparison)
{
rai::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]);
rai::send_block block1 (1, 0, 2, 3, 4, 5);
rai::send_block block1 (1, 0, 2, rai::keypair ().prv, 4, 5);
auto previous1 (block1.previous ());
cache.add (rai::send_block (block1), previous1);
auto existing1 (cache.blocks.find (previous1));
ASSERT_NE (cache.blocks.end (), existing1);
auto arrival (existing1->arrival);
while (std::chrono::system_clock::now () == arrival);
rai::send_block block3 (0, 42, 1, 2, 3, 4);
rai::send_block block3 (0, 42, 1, rai::keypair ().prv, 3, 4);
auto previous2 (block3.previous ());
cache.add (rai::send_block (block3), previous2);
ASSERT_EQ (2, cache.blocks.size ());
@ -55,7 +55,7 @@ TEST (gap_cache, limit)
rai::gap_cache cache (*system.nodes [0]);
for (auto i (0); i < cache.max * 2; ++i)
{
rai::send_block block1 (i, 0, 1, 2, 3, 4);
rai::send_block block1 (i, 0, 1, rai::keypair ().prv, 3, 4);
auto previous (block1.previous ());
cache.add (rai::send_block (block1), previous);
}

11
rai/core_test/ledger.cpp
View file

@ -630,7 +630,7 @@ TEST (ledger, double_open)
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code);
rai::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code);
rai::open_block open2 (send1.hash (), rai::test_genesis_key.pub, key2.pub, key2.pub, key2.prv, 0);
rai::open_block open2 (send1.hash (), rai::test_genesis_key.pub, key2.pub, key2.prv, key2.pub, 0);
ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, open2).code);
}
@ -671,7 +671,8 @@ TEST (votes, add_unsigned)
auto votes1 (node1.conflicts.roots.find (send1.root ())->second);
ASSERT_NE (nullptr, votes1);
ASSERT_EQ (1, votes1->votes.rep_votes.size ());
rai::vote vote1 (key1.pub, 0, 1, send1.clone ());
rai::keypair key2;
rai::vote vote1 (0, key2.prv, 1, send1.clone ());
votes1->vote (vote1);
ASSERT_EQ (1, votes1->votes.rep_votes.size ());
}
@ -1119,7 +1120,7 @@ TEST (ledger, fail_change_bad_signature)
rai::transaction transaction (store.environment, nullptr, true);
genesis.initialize (transaction, store);
rai::keypair key1;
rai::change_block block (genesis.hash (), key1.pub, rai::private_key (0), rai::public_key (0), 0);
rai::change_block block (genesis.hash (), key1.pub, rai::keypair ().prv, 0, 0);
auto result1 (ledger.process (transaction, block));
ASSERT_EQ (rai::process_result::bad_signature, result1.code);
}
@ -1185,7 +1186,7 @@ TEST (ledger, fail_send_bad_signature)
rai::transaction transaction (store.environment, nullptr, true);
genesis.initialize (transaction, store);
rai::keypair key1;
rai::send_block block (genesis.hash (), key1.pub, 1, 0, 0, 0);
rai::send_block block (genesis.hash (), key1.pub, 1, rai::keypair ().prv, 0, 0);
auto result1 (ledger.process (transaction, block));
ASSERT_EQ (rai::process_result::bad_signature, result1.code);
}
@ -1412,7 +1413,7 @@ TEST (ledger, fail_receive_bad_signature)
rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0);
auto result3 (ledger.process (transaction, block3));
ASSERT_EQ (rai::process_result::progress, result3.code);
rai::receive_block block4 (block3.hash (), block2.hash (), 0, 0, 0);
rai::receive_block block4 (block3.hash (), block2.hash (), rai::keypair ().prv, 0, 0);
auto result4 (ledger.process (transaction, block4));
ASSERT_EQ (rai::process_result::bad_signature, result4.code);
}

4
rai/core_test/message.cpp
View file

@ -40,7 +40,7 @@ TEST (message, keepalive_deserialize)
TEST (message, publish_serialization)
{
rai::publish publish (std::unique_ptr <rai::block> (new rai::send_block (0, 1, 2, 3, 4, 5)));
rai::publish publish (std::unique_ptr <rai::block> (new rai::send_block (0, 1, 2, rai::keypair ().prv, 4, 5)));
ASSERT_EQ (rai::block_type::send, publish.block_type ());
ASSERT_FALSE (publish.ipv4_only ());
publish.ipv4_only_set (true);
@ -75,7 +75,7 @@ TEST (message, publish_serialization)
TEST (message, confirm_ack_serialization)
{
rai::keypair key1;
rai::confirm_ack con1 (key1.pub, key1.prv, 0, std::unique_ptr <rai::block> (new rai::send_block (0, 1, 2, 3, 4, 5)));
rai::confirm_ack con1 (key1.pub, key1.prv, 0, std::unique_ptr <rai::block> (new rai::send_block (0, 1, 2, key1.prv, 4, 5)));
std::vector <uint8_t> bytes;
{
rai::vectorstream stream1 (bytes);

8
rai/core_test/message_parser.cpp
View file

@ -58,8 +58,8 @@ TEST (message_parser, exact_confirm_ack_size)
rai::system system (24000, 1);
test_visitor visitor;
rai::message_parser parser (visitor, system.work);
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1))));
rai::confirm_ack message (0, 0, 0, std::move (block));
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))));
rai::confirm_ack message (0, rai::keypair ().prv, 0, std::move (block));
std::vector <uint8_t> bytes;
{
rai::vectorstream stream (bytes);
@ -81,7 +81,7 @@ TEST (message_parser, exact_confirm_req_size)
rai::system system (24000, 1);
test_visitor visitor;
rai::message_parser parser (visitor, system.work);
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1))));
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))));
rai::confirm_req message (std::move (block));
std::vector <uint8_t> bytes;
{
@ -104,7 +104,7 @@ TEST (message_parser, exact_publish_size)
rai::system system (24000, 1);
test_visitor visitor;
rai::message_parser parser (visitor, system.work);
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1))));
auto block (std::unique_ptr <rai::send_block> (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))));
rai::publish message (std::move (block));
std::vector <uint8_t> bytes;
{

6
rai/core_test/network.cpp
View file

@ -148,7 +148,7 @@ TEST (network, multi_keepalive)
TEST (network, send_discarded_publish)
{
rai::system system (24000, 2);
std::unique_ptr <rai::send_block> block (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1)));
std::unique_ptr <rai::send_block> block (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1)));
system.nodes [0]->network.republish_block (std::move (block), 0);
rai::genesis genesis;
ASSERT_EQ (genesis.hash (), system.nodes [0]->latest (rai::test_genesis_key.pub));
@ -431,7 +431,7 @@ TEST (bulk_pull, end_not_owned)
system.wallet (0)->insert (rai::test_genesis_key.prv);
ASSERT_FALSE (system.wallet (0)->send_sync (rai::test_genesis_key.pub, key2.pub, 100).is_zero ());
rai::block_hash latest (system.nodes [0]->latest (rai::test_genesis_key.pub));
rai::open_block open (0, 1, 2, 3, 4, 5);
rai::open_block open (0, 1, 2, rai::keypair ().prv, 4, 5);
open.hashables.account = key2.pub;
open.hashables.representative = key2.pub;
open.hashables.source = latest;
@ -501,7 +501,7 @@ TEST (bootstrap_processor, DISABLED_process_incomplete)
auto frontier_req_client (std::make_shared <rai::frontier_req_client> (node1));
frontier_req_client->pulls [rai::test_genesis_key.pub] = genesis.hash ();
auto bulk_pull_client (std::make_shared <rai::bulk_pull_client> (frontier_req_client));
std::unique_ptr <rai::send_block> block1 (new rai::send_block (0, 1, 2, 3, 4, 5));
std::unique_ptr <rai::send_block> block1 (new rai::send_block (0, 1, 2, rai::keypair ().prv, 4, 5));
bulk_pull_client->process_end ();
}

8
rai/core_test/node.cpp
View file

@ -51,7 +51,7 @@ TEST (node, send_unkeyed)
rai::system system (24000, 1);
rai::keypair key2;
system.wallet (0)->insert (rai::test_genesis_key.prv);
system.wallet (0)->store.password.value_set (rai::uint256_union (1));
system.wallet (0)->store.password.value_set (rai::keypair ().prv);
ASSERT_TRUE (system.wallet (0)->send_sync (rai::test_genesis_key.pub, key2.pub, system.nodes [0]->config.receive_minimum.number ()).is_zero ());
}
@ -237,7 +237,7 @@ TEST (node, receive_gap)
rai::system system (24000, 1);
auto & node1 (*system.nodes [0]);
ASSERT_EQ (0, node1.gap_cache.blocks.size ());
rai::send_block block (0, 1, 2, 3, 4, 5);
rai::send_block block (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::confirm_req message;
message.block = block.clone ();
node1.process_message (message, node1.network.endpoint ());
@ -299,7 +299,7 @@ TEST (node, unlock_search)
ASSERT_LT (iterations1, 200);
}
system.wallet (0)->insert (key2.prv);
system.wallet (0)->store.password.value_set (0);
system.wallet (0)->store.password.value_set (rai::keypair ().prv);
auto node (system.nodes [0]);
ASSERT_FALSE (system.wallet (0)->enter_password (""));
auto iterations2 (0);
@ -427,7 +427,7 @@ TEST (node, confirm_locked)
rai::system system (24000, 1);
system.wallet (0)->insert (rai::test_genesis_key.prv);
system.wallet (0)->enter_password ("1");
rai::send_block block (0, 0, 0, 0, 0, 0);
rai::send_block block (0, 0, 0, rai::keypair ().prv, 0, 0);
system.nodes [0]->process_confirmation (block, rai::endpoint ());
}

23
rai/core_test/rpc.cpp
View file

@ -191,7 +191,7 @@ TEST (rpc, wallet_add)
rai::rpc rpc (system.service, pool, *system.nodes [0], rai::rpc_config (true));
rai::keypair key1;
std::string key_text;
key1.prv.encode_hex (key_text);
key1.prv.data.encode_hex (key_text);
system.wallet (0)->insert (key1.prv);
boost::property_tree::ptree request;
std::string wallet;
@ -247,11 +247,14 @@ TEST (rpc, wallet_password_enter)
{
rai::system system (24000, 1);
auto iterations (0);
while (system.wallet (0)->store.password.value () == 0)
rai::raw_key password_l;
password_l.data.clear ();
while (password_l.data == 0)
{
system.poll ();
++iterations;
ASSERT_LT (iterations, 200);
system.wallet (0)->store.password.value (password_l);
}
auto pool (boost::make_shared <boost::network::utils::thread_pool> ());
rai::rpc rpc (system.service, pool, *system.nodes [0], rai::rpc_config (true));
@ -409,12 +412,12 @@ TEST (rpc, account_move)
rai::keypair key;
destination->insert (rai::test_genesis_key.prv);
rai::keypair source_id;
auto source (system.nodes [0]->wallets.create (source_id.prv));
auto source (system.nodes [0]->wallets.create (source_id.pub));
source->insert (key.prv);
boost::property_tree::ptree request;
request.put ("action", "account_move");
request.put ("wallet", wallet_id.to_string ());
request.put ("source", source_id.prv.to_string ());
request.put ("source", source_id.pub.to_string ());
boost::property_tree::ptree keys;
boost::property_tree::ptree entry;
entry.put ("", key.pub.to_string ());
@ -568,8 +571,8 @@ TEST (rpc, frontier)
for (auto i (0); i < 1000; ++i)
{
rai::keypair key;
source [key.pub] = key.prv;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0));
source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
}
}
rai::keypair key;
@ -604,8 +607,8 @@ TEST (rpc, frontier_limited)
for (auto i (0); i < 1000; ++i)
{
rai::keypair key;
source [key.pub] = key.prv;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0));
source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
}
}
rai::keypair key;
@ -630,8 +633,8 @@ TEST (rpc, frontier_startpoint)
for (auto i (0); i < 1000; ++i)
{
rai::keypair key;
source [key.pub] = key.prv;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0));
source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
}
}
rai::keypair key;

27
rai/core_test/uint256_union.cpp
View file

@ -22,24 +22,31 @@ TEST (unions, identity)
TEST (uint256_union, key_encryption)
{
rai::keypair key1;
rai::uint256_union secret_key;
secret_key.bytes.fill (0);
rai::uint256_union encrypted (key1.prv, secret_key, key1.pub.owords [0]);
rai::private_key key4 (encrypted.prv (secret_key, key1.pub.owords [0]));
rai::raw_key secret_key;
secret_key.data.bytes.fill (0);
rai::uint256_union encrypted;
encrypted.encrypt (key1.prv, secret_key, key1.pub.owords [0]);
rai::raw_key key4;
key4.decrypt (encrypted, secret_key, key1.pub.owords [0]);
ASSERT_EQ (key1.prv, key4);
rai::public_key pub;
ed25519_publickey (key4.bytes.data (), pub.bytes.data ());
ed25519_publickey (key4.data.bytes.data (), pub.bytes.data ());
ASSERT_EQ (key1.pub, pub);
}
TEST (uint256_union, encryption)
{
rai::uint256_union key (0);
rai::uint256_union number1 (1);
rai::uint256_union encrypted1 (number1, key, key.owords [0]);
rai::uint256_union encrypted2 (number1, key, key.owords [0]);
rai::raw_key key;
key.data.clear ();
rai::raw_key number1;
number1.data = 1;
rai::uint256_union encrypted1;
encrypted1.encrypt (number1, key, key.data.owords [0]);
rai::uint256_union encrypted2;
encrypted2.encrypt (number1, key, key.data.owords [0]);
ASSERT_EQ (encrypted1, encrypted2);
auto number2 (encrypted1.prv (key, key.owords [0]));
rai::raw_key number2;
number2.decrypt (encrypted1, key, key.data.owords [0]);
ASSERT_EQ (number1, number2);
}

86
rai/core_test/wallet.cpp
View file

@ -13,7 +13,7 @@ TEST (wallet, no_key)
rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init);
rai::keypair key1;
rai::private_key prv1;
rai::raw_key prv1;
ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv1));
ASSERT_TRUE (wallet.valid_password (transaction));
}
@ -30,12 +30,12 @@ TEST (wallet, retrieval)
rai::keypair key1;
ASSERT_TRUE (wallet.valid_password (transaction));
wallet.insert (transaction, key1.prv);
rai::private_key prv1;
rai::raw_key prv1;
ASSERT_FALSE (wallet.fetch (transaction, key1.pub, prv1));
ASSERT_TRUE (wallet.valid_password (transaction));
ASSERT_EQ (key1.prv, prv1);
wallet.password.values [0]->bytes [16] ^= 1;
rai::private_key prv2;
rai::raw_key prv2;
ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv2));
ASSERT_FALSE (wallet.valid_password (transaction));
}
@ -68,7 +68,11 @@ TEST (wallet, one_item_iteration)
for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i)
{
ASSERT_EQ (key1.pub, i->first);
ASSERT_EQ (key1.prv, rai::wallet_value (i->second).key.prv (wallet.wallet_key (transaction), wallet.salt (transaction).owords [0]));
rai::raw_key password;
wallet.wallet_key (password, transaction);
rai::raw_key key;
key.decrypt (rai::wallet_value (i->second).key, password, wallet.salt (transaction).owords [0]);
ASSERT_EQ (key1.prv, key);
}
}
@ -92,15 +96,19 @@ TEST (wallet, two_item_iteration)
for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i)
{
pubs.insert (i->first);
prvs.insert (rai::wallet_value (i->second).key.prv (wallet.wallet_key (transaction), wallet.salt (transaction).owords [0]));
rai::raw_key password;
wallet.wallet_key (password, transaction);
rai::raw_key key;
key.decrypt (rai::wallet_value (i->second).key, password, wallet.salt (transaction).owords [0]);
prvs.insert (key.data);
}
}
ASSERT_EQ (2, pubs.size ());
ASSERT_EQ (2, prvs.size ());
ASSERT_NE (pubs.end (), pubs.find (key1.pub));
ASSERT_NE (prvs.end (), prvs.find (key1.prv));
ASSERT_NE (prvs.end (), prvs.find (key1.prv.data));
ASSERT_NE (pubs.end (), pubs.find (key2.pub));
ASSERT_NE (prvs.end (), prvs.find (key2.prv));
ASSERT_NE (prvs.end (), prvs.find (key2.prv.data));
}
TEST (wallet, insufficient_spend_one)
@ -238,16 +246,21 @@ TEST (wallet, rekey)
rai::kdf kdf;
rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init);
ASSERT_TRUE (wallet.password.value ().is_zero ());
rai::raw_key password;
wallet.password.value (password);
ASSERT_TRUE (password.data.is_zero ());
ASSERT_FALSE (init);
rai::keypair key1;
wallet.insert (transaction, key1.prv);
rai::uint256_union prv1;
rai::raw_key prv1;
wallet.fetch (transaction, key1.pub, prv1);
ASSERT_EQ (key1.prv, prv1);
ASSERT_FALSE (wallet.rekey (transaction, "1"));
ASSERT_EQ (wallet.derive_key (transaction, "1"), wallet.password.value ());
rai::uint256_union prv2;
wallet.password.value (password);
rai::raw_key password1;
wallet.derive_key (password1, transaction, "1");
ASSERT_EQ (password1, password);
rai::raw_key prv2;
wallet.fetch (transaction, key1.pub, prv2);
ASSERT_EQ (key1.prv, prv2);
*wallet.password.values [0] = 2;
@ -296,10 +309,13 @@ TEST (wallet, hash_password)
rai::kdf kdf;
rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init);
auto hash1 (wallet.derive_key (transaction, ""));
auto hash2 (wallet.derive_key (transaction, ""));
rai::raw_key hash1;
wallet.derive_key (hash1, transaction, "");
rai::raw_key hash2;
wallet.derive_key (hash2, transaction, "");
ASSERT_EQ (hash1, hash2);
auto hash3 (wallet.derive_key (transaction, "a"));
rai::raw_key hash3;
wallet.derive_key (hash3, transaction, "a");
ASSERT_NE (hash1, hash3);
}
@ -311,19 +327,25 @@ TEST (fan, reconstitute)
{
ASSERT_NE (value0, *i);
}
auto value1 (fan.value ());
ASSERT_EQ (value0, value1);
rai::raw_key value1;
fan.value (value1);
ASSERT_EQ (value0, value1.data);
}
TEST (fan, change)
{
rai::uint256_union value0 (0);
rai::uint256_union value1 (1);
rai::raw_key value0;
value0.data = 0;
rai::raw_key value1;
value1.data = 1;
ASSERT_NE (value0, value1);
rai::fan fan (value0, 1024);
ASSERT_EQ (value0, fan.value ());
rai::fan fan (value0.data, 1024);
rai::raw_key value2;
fan.value (value2);
ASSERT_EQ (value0, value2);
fan.value_set (value1);
ASSERT_EQ (value1, fan.value ());
fan.value (value2);
ASSERT_EQ (value1, value2);
}
TEST (wallet, reopen_default_password)
@ -396,7 +418,11 @@ TEST (wallet, serialize_json_empty)
wallet1.serialize_json (transaction, serialized);
rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized);
ASSERT_FALSE (error);
ASSERT_EQ (wallet1.wallet_key (transaction), wallet2.wallet_key (transaction));
rai::raw_key password1;
rai::raw_key password2;
wallet1.wallet_key (password1, transaction);
wallet2.wallet_key (password2, transaction);
ASSERT_EQ (password1, password2);
ASSERT_EQ (wallet1.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
@ -419,12 +445,16 @@ TEST (wallet, serialize_json_one)
wallet1.serialize_json (transaction, serialized);
rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized);
ASSERT_FALSE (error);
ASSERT_EQ (wallet1.wallet_key (transaction), wallet2.wallet_key (transaction));
rai::raw_key password1;
rai::raw_key password2;
wallet1.wallet_key (password1, transaction);
wallet2.wallet_key (password2, transaction);
ASSERT_EQ (password1, password2);
ASSERT_EQ (wallet1.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
ASSERT_TRUE (wallet2.exists (transaction, key.pub));
rai::private_key prv;
rai::raw_key prv;
wallet2.fetch (transaction, key.pub, prv);
ASSERT_EQ (key.prv, prv);
}
@ -448,12 +478,16 @@ TEST (wallet, serialize_json_password)
ASSERT_FALSE (wallet2.valid_password (transaction));
ASSERT_FALSE (wallet2.attempt_password (transaction, "password"));
ASSERT_TRUE (wallet2.valid_password (transaction));
ASSERT_EQ (wallet1.wallet_key (transaction), wallet2.wallet_key (transaction));
rai::raw_key password1;
rai::raw_key password2;
wallet1.wallet_key (password1, transaction);
wallet2.wallet_key (password2, transaction);
ASSERT_EQ (password1, password2);
ASSERT_EQ (wallet1.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
ASSERT_TRUE (wallet2.exists (transaction, key.pub));
rai::private_key prv;
rai::raw_key prv;
wallet2.fetch (transaction, key.pub, prv);
ASSERT_EQ (key.prv, prv);
}

5
rai/core_test/wallets.cpp
View file

@ -29,11 +29,14 @@ TEST (wallets, DISABLED_open_existing)
ASSERT_NE (nullptr, wallet);
ASSERT_EQ (wallet, wallets.open (id));
auto iterations (0);
while (wallet->store.password.value () == 0)
rai::raw_key password;
password.data.clear ();
while (password.data == 0)
{
system.poll ();
++iterations;
ASSERT_LT (iterations, 200);
wallet->store.password.value (password);
}
}
{

41
rai/node/node.cpp
View file

@ -1140,7 +1140,7 @@ rai::uint128_t rai::gap_cache::bootstrap_threshold (MDB_txn * transaction_a)
bool rai::network::confirm_broadcast (std::vector <rai::peer_information> & list_a, std::unique_ptr <rai::block> block_a, uint64_t sequence_a, size_t rebroadcast_a)
{
bool result (false);
node.wallets.foreach_representative ([&result, &block_a, &list_a, this, sequence_a, rebroadcast_a] (rai::public_key const & pub_a, rai::private_key const & prv_a)
node.wallets.foreach_representative ([&result, &block_a, &list_a, this, sequence_a, rebroadcast_a] (rai::public_key const & pub_a, rai::raw_key const & prv_a)
{
auto hash (block_a->hash ());
for (auto j (list_a.begin ()), m (list_a.end ()); j != m; ++j)
@ -1155,7 +1155,7 @@ bool rai::network::confirm_broadcast (std::vector <rai::peer_information> & list
return result;
}
void rai::network::confirm_block (rai::private_key const & prv, rai::public_key const & pub, std::unique_ptr <rai::block> block_a, uint64_t sequence_a, rai::endpoint const & endpoint_a, size_t rebroadcast_a)
void rai::network::confirm_block (rai::raw_key const & prv, rai::public_key const & pub, std::unique_ptr <rai::block> block_a, uint64_t sequence_a, rai::endpoint const & endpoint_a, size_t rebroadcast_a)
{
rai::confirm_ack confirm (pub, prv, sequence_a, std::move (block_a));
std::shared_ptr <std::vector <uint8_t>> bytes (new std::vector <uint8_t>);
@ -1434,7 +1434,7 @@ size_t rai::processor_service::size ()
void rai::node::process_confirmation (rai::block const & block_a, rai::endpoint const & sender)
{
wallets.foreach_representative ([this, &block_a, &sender] (rai::public_key const & pub_a, rai::private_key const & prv_a)
wallets.foreach_representative ([this, &block_a, &sender] (rai::public_key const & pub_a, rai::raw_key const & prv_a)
{
if (config.logging.network_message_logging ())
{
@ -1450,7 +1450,7 @@ vote (error_a, stream_a, block_type ())
{
}
rai::confirm_ack::confirm_ack (rai::account const & account_a, rai::private_key const & prv_a, uint64_t sequence_a, std::unique_ptr <rai::block> block_a) :
rai::confirm_ack::confirm_ack (rai::account const & account_a, rai::raw_key const & prv_a, uint64_t sequence_a, std::unique_ptr <rai::block> block_a) :
message (rai::message_type::confirm_ack),
vote (account_a, prv_a, sequence_a, std::move (block_a))
{
@ -3862,11 +3862,10 @@ bool rai::node::representative_vote (rai::election & election_a, rai::block cons
if (is_representative)
{
auto representative (i->second->store.representative (transaction));
rai::private_key prv;
rai::raw_key prv;
auto error (i->second->store.fetch (transaction, representative, prv));
(void)error;
vote_l = rai::vote (representative, prv, 0, block_a.clone ());
prv.clear ();
result = true;
}
}
@ -3901,22 +3900,21 @@ rai::fan::fan (rai::uint256_union const & key, size_t count_a)
values.push_back (std::move (first));
}
rai::uint256_union rai::fan::value ()
void rai::fan::value (rai::raw_key & prv_a)
{
rai::uint256_union result;
result.clear ();
prv_a.data.clear ();
for (auto & i: values)
{
result ^= *i;
prv_a.data ^= *i;
}
return result;
}
void rai::fan::value_set (rai::uint256_union const & value_a)
void rai::fan::value_set (rai::raw_key const & value_a)
{
auto value_l (value ());
*(values [0]) ^= value_l;
*(values [0]) ^= value_a;
rai::raw_key value_l;
value (value_l);
*(values [0]) ^= value_l.data;
*(values [0]) ^= value_a.data;
}
std::array <uint8_t, 2> constexpr rai::message::magic_number;
@ -4100,10 +4098,13 @@ bool rai::handle_node_options (boost::program_options::variables_map & vm)
else if (vm.count ("diagnostics"))
{
std::cout << "Testing hash function" << std::endl;
rai::send_block send (0, 0, 0, 0, 0, 0);
rai:raw_key key;
key.data.clear ();
rai::send_block send (0, 0, 0, key, 0, 0);
auto hash (send.hash ());
std::cout << "Testing key derivation function" << std::endl;
rai::uint256_union junk1 (0);
rai::raw_key junk1;
junk1.data.clear ();
rai::uint256_union junk2 (0);
rai::kdf kdf;
kdf.phs (junk1, "", junk2);
@ -4111,7 +4112,7 @@ bool rai::handle_node_options (boost::program_options::variables_map & vm)
else if (vm.count ("key_create"))
{
rai::keypair pair;
std::cout << "Private: " << pair.prv.to_string () << std::endl << "Public: " << pair.pub.to_string () << std::endl << "Account: " << pair.pub.to_base58check () << std::endl;
std::cout << "Private: " << pair.prv.data.to_string () << std::endl << "Public: " << pair.pub.to_string () << std::endl << "Account: " << pair.pub.to_base58check () << std::endl;
}
else if (vm.count ("key_expand"))
{
@ -4148,7 +4149,9 @@ bool rai::handle_node_options (boost::program_options::variables_map & vm)
if (!wallet->enter_password (password))
{
rai::transaction transaction (wallet->store.environment, nullptr, true);
wallet->store.insert (transaction, vm ["key"].as <std::string> ());
rai::raw_key key;
key.data.decode_hex (vm ["key"].as <std::string> ());
wallet->store.insert (transaction, key);
}
else
{

4
rai/node/node.hpp
View file

@ -207,7 +207,7 @@ class confirm_ack : public message
{
public:
confirm_ack (bool &, rai::stream &);
confirm_ack (rai::account const &, rai::private_key const &, uint64_t, std::unique_ptr <rai::block>);
confirm_ack (rai::account const &, rai::raw_key const &, uint64_t, std::unique_ptr <rai::block>);
bool deserialize (rai::stream &) override;
void serialize (rai::stream &) override;
void visit (rai::message_visitor &) const override;
@ -489,7 +489,7 @@ public:
void republish_block (std::unique_ptr <rai::block>, size_t);
void publish_broadcast (std::vector <rai::peer_information> &, std::unique_ptr <rai::block>);
bool confirm_broadcast (std::vector <rai::peer_information> &, std::unique_ptr <rai::block>, uint64_t, size_t);
void confirm_block (rai::private_key const &, rai::public_key const &, std::unique_ptr <rai::block>, uint64_t, rai::endpoint const &, size_t);
void confirm_block (rai::raw_key const &, rai::public_key const &, std::unique_ptr <rai::block>, uint64_t, rai::endpoint const &, size_t);
void merge_peers (std::array <rai::endpoint, 8> const &);
void send_keepalive (rai::endpoint const &);
void broadcast_confirm_req (rai::block const &);

10
rai/node/rpc.cpp
View file

@ -753,8 +753,8 @@ void rai::rpc::operator () (boost::network::http::server <rai::rpc>::request con
{
std::string key_text (request_l.get <std::string> ("key"));
std::string wallet_text (request_l.get <std::string> ("wallet"));
rai::private_key key;
auto error (key.decode_hex (key_text));
rai::raw_key key;
auto error (key.data.decode_hex (key_text));
if (!error)
{
rai::uint256_union wallet;
@ -767,7 +767,7 @@ void rai::rpc::operator () (boost::network::http::server <rai::rpc>::request con
rai::transaction transaction (node.store.environment, nullptr, true);
existing->second->store.insert (transaction, key);
rai::public_key pub;
ed25519_publickey (key.bytes.data (), pub.bytes.data ());
ed25519_publickey (key.data.bytes.data (), pub.bytes.data ());
boost::property_tree::ptree response_l;
response_l.put ("account", pub.to_base58check ());
set_response (response, response_l);
@ -840,9 +840,9 @@ void rai::rpc::operator () (boost::network::http::server <rai::rpc>::request con
if (config.enable_control)
{
rai::keypair wallet_id;
auto wallet (node.wallets.create (wallet_id.prv));
auto wallet (node.wallets.create (wallet_id.pub));
boost::property_tree::ptree response_l;
response_l.put ("wallet", wallet_id.prv.to_string ());
response_l.put ("wallet", wallet_id.pub.to_string ());
set_response (response, response_l);
}
else

115
rai/node/wallet.cpp
View file

@ -186,28 +186,30 @@ rai::uint256_union rai::wallet_store::salt (MDB_txn * transaction_a)
return value.key;
}
rai::uint256_union rai::wallet_store::wallet_key (MDB_txn * transaction_a)
void rai::wallet_store::wallet_key (rai::raw_key & prv_a, MDB_txn * transaction_a)
{
rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::wallet_key_special));
auto password_l (password.value ());
auto result (value.key.prv (password_l, salt (transaction_a).owords [0]));
password_l.clear ();
return result;
rai::raw_key password_l;
password.value (password_l);
prv_a.decrypt (value.key, password_l, salt (transaction_a).owords [0]);
}
bool rai::wallet_store::valid_password (MDB_txn * transaction_a)
{
rai::uint256_union zero;
zero.clear ();
auto wallet_key_l (wallet_key (transaction_a));
rai::uint256_union check_l (zero, wallet_key_l, salt (transaction_a).owords [0]);
wallet_key_l.clear ();
rai::raw_key zero;
zero.data.clear ();
rai::raw_key wallet_key_l;
wallet_key (wallet_key_l, transaction_a);
rai::uint256_union check_l;
check_l.encrypt (zero, wallet_key_l, salt (transaction_a).owords [0]);
return check (transaction_a) == check_l;
}
bool rai::wallet_store::attempt_password (MDB_txn * transaction_a, std::string const & password_a)
{
password.value_set (derive_key (transaction_a, password_a));
rai::raw_key password_l;
derive_key (password_l, transaction_a, password_a);
password.value_set (password_l);
auto result (!valid_password (transaction_a));
return result;
}
@ -217,14 +219,17 @@ bool rai::wallet_store::rekey (MDB_txn * transaction_a, std::string const & pass
bool result (false);
if (valid_password (transaction_a))
{
auto password_new (derive_key (transaction_a, password_a));
auto wallet_key_l (wallet_key (transaction_a));
auto password_l (password.value ());
(*password.values [0]) ^= password_l;
(*password.values [0]) ^= password_new;
rai::uint256_union encrypted (wallet_key_l, password_new, salt (transaction_a).owords [0]);
rai::raw_key password_new;
derive_key (password_new, transaction_a, password_a);
rai::raw_key wallet_key_l;
wallet_key (wallet_key_l, transaction_a);
rai::raw_key password_l;
password.value (password_l);
(*password.values [0]) ^= password_l.data;
(*password.values [0]) ^= password_new.data;
rai::uint256_union encrypted;
encrypted.encrypt (wallet_key_l, password_new, salt (transaction_a).owords [0]);
entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted));
wallet_key_l.clear ();
}
else
{
@ -233,12 +238,10 @@ bool rai::wallet_store::rekey (MDB_txn * transaction_a, std::string const & pass
return result;
}
rai::uint256_union rai::wallet_store::derive_key (MDB_txn * transaction_a, std::string const & password_a)
void rai::wallet_store::derive_key (rai::raw_key & prv_a, MDB_txn * transaction_a, std::string const & password_a)
{
rai::uint256_union result;
auto salt_l (salt (transaction_a));
kdf.phs (result, password_a, salt_l);
return result;
kdf.phs (prv_a, password_a, salt_l);
}
rai::wallet_value::wallet_value (MDB_val const & val_a)
@ -310,7 +313,9 @@ environment (transaction_a.environment)
init_a = init_a || mdb_get (transaction_a, handle, salt_special.val (), &junk) != 0;
init_a = init_a || mdb_get (transaction_a, handle, check_special.val (), &junk) != 0;
init_a = init_a || mdb_get (transaction_a, handle, representative_special.val (), &junk) != 0;
password.value_set (0);
rai::raw_key key;
key.data.clear();
password.value_set (key);
}
}
@ -333,16 +338,20 @@ environment (transaction_a.environment)
random_pool.GenerateBlock (salt_l.bytes.data (), salt_l.bytes.size ());
entry_put_raw (transaction_a, rai::wallet_store::salt_special, rai::wallet_value (salt_l));
// Wallet key is a fixed random key that encrypts all entries
rai::uint256_union wallet_key;
random_pool.GenerateBlock (wallet_key.bytes.data (), sizeof (wallet_key.bytes));
password.value_set (0);
rai::raw_key wallet_key;
random_pool.GenerateBlock (wallet_key.data.bytes.data (), sizeof (wallet_key.data.bytes));
rai::raw_key password_l;
password_l.data.clear ();
password.value_set (password_l);
rai::raw_key zero;
zero.data.clear ();
// Wallet key is encrypted by the user's password
rai::uint256_union encrypted (wallet_key, 0, salt_l.owords [0]);
rai::uint256_union encrypted;
encrypted.encrypt (wallet_key, zero, salt_l.owords [0]);
entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted));
rai::uint256_union zero (0);
rai::uint256_union check (zero, wallet_key, salt_l.owords [0]);
rai::uint256_union check;
check.encrypt (zero, wallet_key, salt_l.owords [0]);
entry_put_raw (transaction_a, rai::wallet_store::check_special, rai::wallet_value (check));
wallet_key.clear ();
entry_put_raw (transaction_a, rai::wallet_store::representative_special, rai::wallet_value (representative_a));
}
}
@ -382,11 +391,15 @@ rai::account rai::wallet_store::representative (MDB_txn * transaction_a)
return value.key;
}
rai::public_key rai::wallet_store::insert (MDB_txn * transaction_a, rai::private_key const & prv)
rai::public_key rai::wallet_store::insert (MDB_txn * transaction_a, rai::raw_key const & prv)
{
rai::public_key pub;
ed25519_publickey (prv.bytes.data (), pub.bytes.data ());
entry_put_raw (transaction_a, pub, rai::wallet_value (rai::uint256_union (prv, wallet_key (transaction_a), salt (transaction_a).owords [0])));
ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ());
rai::raw_key password_l;
wallet_key (password_l, transaction_a);
rai::uint256_union ciphertext;
ciphertext.encrypt (prv, password_l, salt (transaction_a).owords [0]);
entry_put_raw (transaction_a, pub, rai::wallet_value (ciphertext));
return pub;
}
@ -419,15 +432,17 @@ void rai::wallet_store::entry_put_raw (MDB_txn * transaction_a, rai::public_key
assert (status == 0);
}
bool rai::wallet_store::fetch (MDB_txn * transaction_a, rai::public_key const & pub, rai::private_key & prv)
bool rai::wallet_store::fetch (MDB_txn * transaction_a, rai::public_key const & pub, rai::raw_key & prv)
{
auto result (false);
rai::wallet_value value (entry_get_raw (transaction_a, pub));
if (!value.key.is_zero ())
{
prv = value.key.prv (wallet_key (transaction_a), salt (transaction_a).owords [0]);
rai::raw_key password_l;
wallet_key (password_l, transaction_a);
prv.decrypt (value.key, password_l, salt (transaction_a).owords [0]);
rai::public_key compare;
ed25519_publickey (prv.bytes.data (), compare.bytes.data ());
ed25519_publickey (prv.data.bytes.data (), compare.bytes.data ());
if (!(pub == compare))
{
result = true;
@ -476,7 +491,7 @@ bool rai::wallet_store::move (MDB_txn * transaction_a, rai::wallet_store & other
auto result (false);
for (auto i (keys.begin ()), n (keys.end ()); i != n; ++i)
{
rai::private_key prv;
rai::raw_key prv;
auto error (other_a.fetch (transaction_a, *i, prv));
result = result | error;
if (!result)
@ -495,7 +510,7 @@ bool rai::wallet_store::import (MDB_txn * transaction_a, rai::wallet_store & oth
auto result (false);
for (auto i (other_a.begin (transaction_a)), n (end ()); i != n; ++i)
{
rai::private_key prv;
rai::raw_key prv;
auto error (other_a.fetch (transaction_a, i->first, prv));
result = result | error;
if (!result)
@ -530,10 +545,10 @@ void rai::wallet_store::work_put (MDB_txn * transaction_a, rai::public_key const
entry_put_raw (transaction_a, pub_a, entry);
}
void rai::kdf::phs (rai::uint256_union & result_a, std::string const & password_a, rai::uint256_union const & salt_a)
void rai::kdf::phs (rai::raw_key & result_a, std::string const & password_a, rai::uint256_union const & salt_a)
{
std::lock_guard <std::mutex> lock (mutex);
auto success (PHS (result_a.bytes.data (), result_a.bytes.size (), password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), 1, rai::wallet_store::kdf_work));
auto success (PHS (result_a.data.bytes.data (), result_a.data.bytes.size (), password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), 1, rai::wallet_store::kdf_work));
assert (success == 0); (void) success;
}
@ -553,7 +568,9 @@ node (node_a)
void rai::wallet::enter_initial_password ()
{
if (store.password.value ().is_zero ())
rai::raw_key password_l;
store.password.value (password_l);
if (password_l.data.is_zero ())
{
if (valid_password ())
{
@ -588,7 +605,7 @@ bool rai::wallet::enter_password (std::string const & password_a)
return result;
}
rai::public_key rai::wallet::insert (rai::private_key const & key_a)
rai::public_key rai::wallet::insert (rai::raw_key const & key_a)
{
rai::block_hash root;
rai::public_key key;
@ -660,7 +677,7 @@ bool rai::wallet::receive_action (rai::send_block const & send_a, rai::account c
rai::transaction transaction (node.ledger.store.environment, nullptr, false);
if (node.ledger.store.pending_exists (transaction, hash))
{
rai::private_key prv;
rai::raw_key prv;
if (!store.fetch (transaction, send_a.hashables.destination, prv))
{
rai::account_info info;
@ -681,7 +698,6 @@ bool rai::wallet::receive_action (rai::send_block const & send_a, rai::account c
result = true;
BOOST_LOG (node.log) << "Unable to receive, wallet locked";
}
prv.clear ();
}
else
{
@ -722,11 +738,10 @@ bool rai::wallet::change_action (rai::account const & source_a, rai::account con
rai::account_info info;
result = node.ledger.store.account_get (transaction, source_a, info);
assert (!result);
rai::private_key prv;
rai::raw_key prv;
result = store.fetch (transaction, source_a, prv);
assert (!result);
block.reset (new rai::change_block (info.head, representative_a, prv, source_a, work_fetch (transaction, source_a, info.head)));
prv.clear ();
}
else
{
@ -769,11 +784,10 @@ rai::block_hash rai::wallet::send_action (rai::account const & source_a, rai::ac
rai::account_info info;
result = node.ledger.store.account_get (transaction, source_a, info);
assert (!result);
rai::private_key prv;
rai::raw_key prv;
result = store.fetch (transaction, source_a, prv);
assert (!result);
block.reset (new rai::send_block (info.head, account_a, balance - amount_a, prv, source_a, work_fetch (transaction, source_a, info.head)));
prv.clear ();
}
else
{
@ -1129,7 +1143,7 @@ void rai::wallets::queue_wallet_action (rai::account const & account_a, rai::uin
}
}
void rai::wallets::foreach_representative (std::function <void (rai::public_key const & pub_a, rai::private_key const & prv_a)> const & action_a)
void rai::wallets::foreach_representative (std::function <void (rai::public_key const & pub_a, rai::raw_key const & prv_a)> const & action_a)
{
for (auto i (items.begin ()), n (items.end ()); i != n; ++i)
{
@ -1142,11 +1156,10 @@ void rai::wallets::foreach_representative (std::function <void (rai::public_key
{
if (wallet.store.valid_password (transaction))
{
rai::private_key prv;
rai::raw_key prv;
auto error (wallet.store.fetch (transaction, j->first, prv));
assert (!error);
action_a (j->first, prv);
prv.clear ();
}
else
{

18
rai/node/wallet.hpp
View file

@ -41,8 +41,8 @@ class fan
{
public:
fan (rai::uint256_union const &, size_t);
rai::uint256_union value ();
void value_set (rai::uint256_union const &);
void value (rai::raw_key &);
void value_set (rai::raw_key const &);
std::vector <std::unique_ptr <rai::uint256_union>> values;
};
class wallet_value
@ -59,7 +59,7 @@ class node_config;
class kdf
{
public:
void phs (rai::uint256_union &, std::string const &, rai::uint256_union const &);
void phs (rai::raw_key &, std::string const &, rai::uint256_union const &);
std::mutex mutex;
};
class wallet_store
@ -73,22 +73,22 @@ public:
bool rekey (MDB_txn *, std::string const &);
bool valid_password (MDB_txn *);
bool attempt_password (MDB_txn *, std::string const &);
rai::uint256_union wallet_key (MDB_txn *);
void wallet_key (rai::raw_key &, MDB_txn *);
rai::uint256_union salt (MDB_txn *);
bool is_representative (MDB_txn *);
rai::account representative (MDB_txn *);
void representative_set (MDB_txn *, rai::account const &);
rai::public_key insert (MDB_txn *, rai::private_key const &);
rai::public_key insert (MDB_txn *, rai::raw_key const &);
void erase (MDB_txn *, rai::public_key const &);
rai::wallet_value entry_get_raw (MDB_txn *, rai::public_key const &);
void entry_put_raw (MDB_txn *, rai::public_key const &, rai::wallet_value const &);
bool fetch (MDB_txn *, rai::public_key const &, rai::private_key &);
bool fetch (MDB_txn *, rai::public_key const &, rai::raw_key &);
bool exists (MDB_txn *, rai::public_key const &);
void destroy (MDB_txn *);
rai::store_iterator find (MDB_txn *, rai::uint256_union const &);
rai::store_iterator begin (MDB_txn *);
rai::store_iterator end ();
rai::uint256_union derive_key (MDB_txn *, std::string const &);
void derive_key (rai::raw_key &, MDB_txn *, std::string const &);
void serialize_json (MDB_txn *, std::string &);
void write_backup (MDB_txn *, boost::filesystem::path const &);
bool move (MDB_txn *, rai::wallet_store &, std::vector <rai::public_key> const &);
@ -121,7 +121,7 @@ public:
void enter_initial_password ();
bool valid_password ();
bool enter_password (std::string const &);
rai::public_key insert (rai::private_key const &);
rai::public_key insert (rai::raw_key const &);
bool exists (rai::public_key const &);
bool import (std::string const &, std::string const &);
void serialize (std::string &);
@ -149,7 +149,7 @@ public:
bool search_pending (rai::uint256_union const &);
void destroy (rai::uint256_union const &);
void queue_wallet_action (rai::account const &, rai::uint128_t const &, std::function <void ()> const &);
void foreach_representative (std::function <void (rai::public_key const &, rai::private_key const &)> const &);
void foreach_representative (std::function <void (rai::public_key const &, rai::raw_key const &)> const &);
std::function <void (rai::account const &, bool)> observer;
std::unordered_map <rai::uint256_union, std::shared_ptr <rai::wallet>> items;
std::unordered_map <rai::account, std::multimap <rai::uint128_t, std::function <void ()>, std::greater <rai::uint128_t>>> pending_actions;

20
rai/qt/qt.cpp
View file

@ -113,8 +113,8 @@ wallet (wallet_a)
{
QString key_text_wide (account_key_line->text ());
std::string key_text (key_text_wide.toLocal8Bit ());
rai::private_key key;
if (!key.decode_hex (key_text))
rai::raw_key key;
if (!key.data.decode_hex (key_text))
{
show_line_ok (*account_key_line);
account_key_line->clear ();
@ -776,8 +776,8 @@ wallet (wallet_a)
});
QObject::connect (lock, &QPushButton::released, [this] ()
{
rai::uint256_union empty;
empty.clear ();
rai::raw_key empty;
empty.data.clear ();
wallet.wallet_m->store.password.value_set (empty);
update_locked (true, true);
});
@ -1206,7 +1206,7 @@ void rai_qt::block_creation::create_send ()
if (!error)
{
rai::transaction transaction (wallet.node.store.environment, nullptr, false);
rai::private_key key;
rai::raw_key key;
if (!wallet.wallet_m->store.fetch (transaction, account_l, key))
{
auto balance (wallet.node.ledger.account_balance (transaction, account_l));
@ -1216,7 +1216,6 @@ void rai_qt::block_creation::create_send ()
auto error (wallet.node.store.account_get (transaction, account_l, info));
assert (!error);
rai::send_block send (info.head, destination_l, balance - amount_l.number (), key, account_l, wallet.wallet_m->work_fetch (transaction, account_l, info.head));
key.clear ();
std::string block_l;
send.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ()));
@ -1268,12 +1267,11 @@ void rai_qt::block_creation::create_receive ()
auto error (wallet.node.store.account_get (transaction, receivable.destination, info));
if (!error)
{
rai::private_key key;
rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key));
if (!error)
{
rai::receive_block receive (info.head, source_l, key, receivable.destination, wallet.wallet_m->work_fetch (transaction, receivable.destination, info.head));
key.clear ();
std::string block_l;
receive.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ()));
@ -1320,12 +1318,11 @@ void rai_qt::block_creation::create_change ()
auto error (wallet.node.store.account_get (transaction, account_l, info));
if (!error)
{
rai::private_key key;
rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, account_l, key));
if (!error)
{
rai::change_block change (info.head, representative_l, key, account_l, wallet.wallet_m->work_fetch (transaction, account_l, info.head));
key.clear ();
std::string block_l;
change.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ()));
@ -1375,12 +1372,11 @@ void rai_qt::block_creation::create_open ()
auto error (wallet.node.store.account_get (transaction, receivable.destination, info));
if (error)
{
rai::private_key key;
rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key));
if (!error)
{
rai::open_block open (source_l, representative_l, receivable.destination, key, receivable.destination, wallet.wallet_m->work_fetch (transaction, receivable.destination, receivable.destination));
key.clear ();
std::string block_l;
open.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ()));

35
rai/qt_test/qt.cpp
View file

@ -59,8 +59,8 @@ TEST (wallet, select_account)
{
rai::system system (24000, 1);
auto wallet_l (system.nodes [0]->wallets.create (rai::uint256_union ()));
rai::public_key key1 (wallet_l->insert (1));
rai::public_key key2 (wallet_l->insert (2));
rai::public_key key1 (wallet_l->insert (rai::keypair ().prv));
rai::public_key key2 (wallet_l->insert (rai::keypair ().prv));
rai_qt::wallet wallet (*test_application, *system.nodes [0], wallet_l, key1);
ASSERT_EQ (key1, wallet.account);
QTest::mouseClick (wallet.show_advanced, Qt::LeftButton);
@ -116,14 +116,22 @@ TEST (wallet, password_change)
QTest::mouseClick (wallet.settings_button, Qt::LeftButton);
{
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
ASSERT_NE (system.wallet (0)->store.derive_key (transaction, "1"), system.wallet (0)->store.password.value ());
rai::raw_key password1;
rai::raw_key password2;
system.wallet (0)->store.derive_key (password1, transaction, "1");
system.wallet (0)->store.password.value (password2);
ASSERT_NE (password1, password2);
}
QTest::keyClicks (wallet.settings.new_password, "1");
QTest::keyClicks (wallet.settings.retype_password, "1");
QTest::mouseClick (wallet.settings.change, Qt::LeftButton);
{
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
ASSERT_EQ (system.wallet (0)->store.derive_key (transaction, "1"), system.wallet (0)->store.password.value ());
rai::raw_key password1;
rai::raw_key password2;
system.wallet (0)->store.derive_key (password1, transaction, "1");
system.wallet (0)->store.password.value (password2);
ASSERT_EQ (password1, password2);
}
ASSERT_EQ ("", wallet.settings.new_password->text ());
ASSERT_EQ ("", wallet.settings.retype_password->text ());
@ -141,22 +149,33 @@ TEST (client, password_nochange)
rai_qt::wallet wallet (*test_application, *system.nodes [0], system.wallet (0), account);
QTest::mouseClick (wallet.settings_button, Qt::LeftButton);
auto iterations (0);
while (system.wallet (0)->store.password.value () == 0)
rai::raw_key password;
password.data.clear ();
while (password.data == 0)
{
system.poll ();
++iterations;
ASSERT_LT (iterations, 200);
system.wallet (0)->store.password.value (password);
}
{
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
ASSERT_EQ (system.wallet (0)->store.derive_key (transaction, ""), system.wallet (0)->store.password.value ());
rai::raw_key password1;
system.wallet (0)->store.derive_key (password1, transaction, "");
rai::raw_key password2;
system.wallet (0)->store.password.value (password2);
ASSERT_EQ (password1, password2);
}
QTest::keyClicks (wallet.settings.new_password, "1");
QTest::keyClicks (wallet.settings.retype_password, "2");
QTest::mouseClick (wallet.settings.change, Qt::LeftButton);
{
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
ASSERT_EQ (system.wallet (0)->store.derive_key (transaction, ""), system.wallet (0)->store.password.value ());
rai::raw_key password1;
system.wallet (0)->store.derive_key (password1, transaction, "");
rai::raw_key password2;
system.wallet (0)->store.password.value (password2);
ASSERT_EQ (password1, password2);
}
ASSERT_EQ ("1", wallet.settings.new_password->text ());
ASSERT_EQ ("", wallet.settings.retype_password->text ());
@ -198,7 +217,7 @@ TEST (wallet, send)
{
rai::system system (24000, 2);
system.wallet (0)->insert (rai::test_genesis_key.prv);
rai::public_key key1 (system.wallet (1)->insert (1));
rai::public_key key1 (system.wallet (1)->insert (rai::keypair ().prv));
rai_qt::wallet wallet (*test_application, *system.nodes [0], system.wallet (0), rai::test_genesis_key.pub);
QTest::mouseClick (wallet.send_blocks, Qt::LeftButton);
QTest::keyClicks (wallet.send_account, key1.to_base58check ().c_str ());

12
rai/rai_node/entry.cpp
View file

@ -141,13 +141,13 @@ int main (int argc, char * const * argv)
{
rai::keypair genesis (key.to_string ());
rai::work_pool work;
std::cout << "Genesis: " << genesis.prv.to_string () << std::endl << "Public: " << genesis.pub.to_string () << std::endl << "Account: " << genesis.pub.to_base58check () << std::endl;
std::cout << "Genesis: " << genesis.prv.data.to_string () << std::endl << "Public: " << genesis.pub.to_string () << std::endl << "Account: " << genesis.pub.to_base58check () << std::endl;
rai::keypair landing;
std::cout << "Landing: " << landing.prv.to_string () << std::endl << "Public: " << landing.pub.to_string () << std::endl << "Account: " << landing.pub.to_base58check () << std::endl;
std::cout << "Landing: " << landing.prv.data.to_string () << std::endl << "Public: " << landing.pub.to_string () << std::endl << "Account: " << landing.pub.to_base58check () << std::endl;
for (auto i (0); i != 32; ++i)
{
rai::keypair rep;
std::cout << "Rep" << i << ": " << rep.prv.to_string () << std::endl << "Public: " << rep.pub.to_string () << std::endl << "Account: " << rep.pub.to_base58check () << std::endl;
std::cout << "Rep" << i << ": " << rep.prv.data.to_string () << std::endl << "Public: " << rep.pub.to_string () << std::endl << "Account: " << rep.pub.to_base58check () << std::endl;
}
rai::uint128_t balance (std::numeric_limits <rai::uint128_t>::max ());
rai::open_block genesis_block (genesis.pub, genesis.pub, genesis.pub, genesis.prv, genesis.pub, work.generate (genesis.pub));
@ -202,7 +202,7 @@ int main (int argc, char * const * argv)
else if (vm.count ("debug_profile_generate"))
{
rai::work_pool work;
rai::change_block block (0, 0, 0, 0, 0);
rai::change_block block (0, 0, rai::keypair ().prv, 0, 0);
std::cerr << "Starting generation profiling\n";
for (uint64_t i (0); true; ++i)
{
@ -216,7 +216,7 @@ int main (int argc, char * const * argv)
else if (vm.count ("debug_profile_verify"))
{
rai::work_pool work;
rai::change_block block (0, 0, 0, 0, 0);
rai::change_block block (0, 0, rai::keypair ().prv, 0, 0);
std::cerr << "Starting verification profiling\n";
for (uint64_t i (0); true; ++i)
{
@ -236,7 +236,7 @@ int main (int argc, char * const * argv)
auto begin (std::chrono::high_resolution_clock::now ());
for (auto i (0u); i < 1000; ++i)
{
rai::validate_message (key.pub, key.prv, signature);
rai::validate_message (key.pub, message, signature);
}
auto end (std::chrono::high_resolution_clock::now ());
std::cerr << "Signature verifications " << std::chrono::duration_cast <std::chrono::microseconds> (end - begin).count () << std::endl;

18
rai/secure.cpp
View file

@ -161,16 +161,16 @@ id (id_a)
// Create a new random keypair
rai::keypair::keypair ()
{
random_pool.GenerateBlock (prv.bytes.data (), prv.bytes.size ());
ed25519_publickey (prv.bytes.data (), pub.bytes.data ());
random_pool.GenerateBlock (prv.data.bytes.data (), prv.data.bytes.size ());
ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ());
}
// Create a keypair given a hex string of the private key
rai::keypair::keypair (std::string const & prv_a)
{
auto error (prv.decode_hex (prv_a));
auto error (prv.data.decode_hex (prv_a));
assert (!error);
ed25519_publickey (prv.bytes.data (), pub.bytes.data ());
ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ());
}
rai::ledger::ledger (rai::block_store & store_a) :
@ -427,7 +427,7 @@ void rai::receive_block::serialize_json (std::string & string_a) const
string_a = ostream.str ();
}
rai::receive_block::receive_block (rai::block_hash const & previous_a, rai::block_hash const & source_a, rai::private_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
rai::receive_block::receive_block (rai::block_hash const & previous_a, rai::block_hash const & source_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, source_a),
signature (rai::sign_message (prv_a, pub_a, hash())),
work (work_a)
@ -708,7 +708,7 @@ std::unique_ptr <rai::block> rai::deserialize_block (rai::stream & stream_a)
return result;
}
rai::send_block::send_block (rai::block_hash const & previous_a, rai::account const & destination_a, rai::amount const & balance_a, rai::private_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
rai::send_block::send_block (rai::block_hash const & previous_a, rai::account const & destination_a, rai::amount const & balance_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, destination_a, balance_a),
signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a)
@ -847,7 +847,7 @@ void rai::open_hashables::hash (blake2b_state & hash_a) const
blake2b_update (&hash_a, account.bytes.data (), sizeof (account.bytes));
}
rai::open_block::open_block (rai::block_hash const & source_a, rai::account const & representative_a, rai::account const & account_a, rai::private_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
rai::open_block::open_block (rai::block_hash const & source_a, rai::account const & representative_a, rai::account const & account_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
hashables (source_a, representative_a, account_a),
signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a)
@ -1086,7 +1086,7 @@ void rai::change_hashables::hash (blake2b_state & hash_a) const
blake2b_update (&hash_a, representative.bytes.data (), sizeof (representative.bytes));
}
rai::change_block::change_block (rai::block_hash const & previous_a, rai::account const & representative_a, rai::private_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
rai::change_block::change_block (rai::block_hash const & previous_a, rai::account const & representative_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) :
hashables (previous_a, representative_a),
signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a)
@ -2813,7 +2813,7 @@ rai::vote::vote (bool & error_a, rai::stream & stream_a, rai::block_type type_a)
}
}
rai::vote::vote (rai::account const & account_a, rai::private_key const & prv_a, uint64_t sequence_a, std::unique_ptr <rai::block> block_a) :
rai::vote::vote (rai::account const & account_a, rai::raw_key const & prv_a, uint64_t sequence_a, std::unique_ptr <rai::block> block_a) :
sequence (sequence_a),
block (std::move (block_a)),
account (account_a),

12
rai/secure.hpp
View file

@ -45,7 +45,7 @@ public:
keypair ();
keypair (std::string const &);
rai::public_key pub;
rai::private_key prv;
rai::raw_key prv;
};
class block_visitor;
enum class block_type : uint8_t
@ -105,7 +105,7 @@ public:
class send_block : public rai::block
{
public:
send_block (rai::block_hash const &, rai::account const &, rai::amount const &, rai::private_key const &, rai::public_key const &, uint64_t);
send_block (rai::block_hash const &, rai::account const &, rai::amount const &, rai::raw_key const &, rai::public_key const &, uint64_t);
send_block (bool &, rai::stream &);
send_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash;
@ -143,7 +143,7 @@ public:
class receive_block : public rai::block
{
public:
receive_block (rai::block_hash const &, rai::block_hash const &, rai::private_key const &, rai::public_key const &, uint64_t);
receive_block (rai::block_hash const &, rai::block_hash const &, rai::raw_key const &, rai::public_key const &, uint64_t);
receive_block (bool &, rai::stream &);
receive_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash;
@ -182,7 +182,7 @@ public:
class open_block : public rai::block
{
public:
open_block (rai::block_hash const &, rai::account const &, rai::account const &, rai::private_key const &, rai::public_key const &, uint64_t);
open_block (rai::block_hash const &, rai::account const &, rai::account const &, rai::raw_key const &, rai::public_key const &, uint64_t);
open_block (rai::block_hash const &, rai::account const &, rai::account const &, std::nullptr_t);
open_block (bool &, rai::stream &);
open_block (bool &, boost::property_tree::ptree const &);
@ -221,7 +221,7 @@ public:
class change_block : public rai::block
{
public:
change_block (rai::block_hash const &, rai::account const &, rai::private_key const &, rai::public_key const &, uint64_t);
change_block (rai::block_hash const &, rai::account const &, rai::raw_key const &, rai::public_key const &, uint64_t);
change_block (bool &, rai::stream &);
change_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash;
@ -425,7 +425,7 @@ class vote
public:
vote () = default;
vote (bool &, rai::stream &, rai::block_type);
vote (rai::account const &, rai::private_key const &, uint64_t, std::unique_ptr <rai::block>);
vote (rai::account const &, rai::raw_key const &, uint64_t, std::unique_ptr <rai::block>);
rai::uint256_union hash () const;
// Vote round sequence number
uint64_t sequence;

44
rai/utility.cpp
View file

@ -303,12 +303,11 @@ bool rai::uint256_union::operator == (rai::uint256_union const & other_a) const
}
// Construct a uint256_union = AES_ENC_CTR (cleartext, key, iv)
rai::uint256_union::uint256_union (rai::private_key const & cleartext, rai::secret_key const & key, uint128_union const & iv)
void rai::uint256_union::encrypt (rai::raw_key const & cleartext, rai::raw_key const & key, uint128_union const & iv)
{
rai::uint256_union exponent (cleartext);
CryptoPP::AES::Encryption alg (key.bytes.data (), sizeof (key.bytes));
CryptoPP::AES::Encryption alg (key.data.bytes.data (), sizeof (key.data.bytes));
CryptoPP::CTR_Mode_ExternalCipher::Encryption enc (alg, iv.bytes.data ());
enc.ProcessData (bytes.data (), exponent.bytes.data (), sizeof (exponent.bytes));
enc.ProcessData (bytes.data (), cleartext.data.bytes.data (), sizeof (cleartext.data.bytes));
}
rai::uint256_union::uint256_union (MDB_val const & val_a)
@ -318,16 +317,6 @@ rai::uint256_union::uint256_union (MDB_val const & val_a)
std::copy (reinterpret_cast <uint8_t const *> (val_a.mv_data), reinterpret_cast <uint8_t const *> (val_a.mv_data) + sizeof (*this), bytes.data ());
}
// Return a uint256_union = AES_DEC_CTR (this, key, iv)
rai::private_key rai::uint256_union::prv (rai::secret_key const & key_a, uint128_union const & iv) const
{
CryptoPP::AES::Encryption alg (key_a.bytes.data (), sizeof (key_a.bytes));
CryptoPP::CTR_Mode_ExternalCipher::Decryption dec (alg, iv.bytes.data ());
rai::private_key result;
dec.ProcessData (result.bytes.data (), bytes.data (), sizeof (bytes));
return result;
}
bool rai::uint256_union::is_zero () const
{
return qwords [0] == 0 && qwords [1] == 0 && qwords [2] == 0 && qwords [3] == 0;
@ -475,6 +464,29 @@ bool rai::uint256_union::operator != (rai::uint256_union const & other_a) const
return ! (*this == other_a);
}
rai::raw_key::~raw_key ()
{
data.clear ();
}
bool rai::raw_key::operator == (rai::raw_key const & other_a) const
{
return data == other_a.data;
}
bool rai::raw_key::operator != (rai::raw_key const & other_a) const
{
return !(*this == other_a);
}
// This this = AES_DEC_CTR (ciphertext, key, iv)
void rai::raw_key::decrypt (rai::uint256_union const & ciphertext, rai::raw_key const & key_a, uint128_union const & iv)
{
CryptoPP::AES::Encryption alg (key_a.data.bytes.data (), sizeof (key_a.data.bytes));
CryptoPP::CTR_Mode_ExternalCipher::Decryption dec (alg, iv.bytes.data ());
dec.ProcessData (data.bytes.data (), ciphertext.bytes.data (), sizeof (ciphertext.bytes));
}
// Base58check is an encoding using [0-9][a-z][A-Z] excluding characters that can be confused
// Base58check also has a 32bit error correction code.
namespace
@ -675,10 +687,10 @@ void ed25519_hash (uint8_t * out, uint8_t const * in, size_t inlen)
}
}
rai::uint512_union rai::sign_message (rai::private_key const & private_key, rai::public_key const & public_key, rai::uint256_union const & message)
rai::uint512_union rai::sign_message (rai::raw_key const & private_key, rai::public_key const & public_key, rai::uint256_union const & message)
{
rai::uint512_union result;
ed25519_sign (message.bytes.data (), sizeof (message.bytes), private_key.bytes.data (), public_key.bytes.data (), result.bytes.data ());
ed25519_sign (message.bytes.data (), sizeof (message.bytes), private_key.data.bytes.data (), public_key.bytes.data (), result.bytes.data ());
return result;
}

19
rai/utility.hpp
View file

@ -116,15 +116,15 @@ public:
};
// Balances are 128 bit.
using amount = uint128_union;
class raw_key;
union uint256_union
{
uint256_union () = default;
uint256_union (std::string const &);
uint256_union (uint64_t);
uint256_union (rai::uint256_t const &);
uint256_union (rai::uint256_union const &, rai::uint256_union const &, uint128_union const &);
uint256_union (MDB_val const &);
uint256_union prv (uint256_union const &, uint128_union const &) const;
void encrypt (rai::raw_key const &, rai::raw_key const &, uint128_union const &);
uint256_union & operator ^= (rai::uint256_union const &);
uint256_union operator ^ (rai::uint256_union const &) const;
bool operator == (rai::uint256_union const &) const;
@ -154,6 +154,19 @@ using public_key = uint256_union;
using private_key = uint256_union;
using secret_key = uint256_union;
using checksum = uint256_union;
class raw_key
{
public:
raw_key () = default;
~raw_key ();
void decrypt (rai::uint256_union const &, rai::raw_key const &, uint128_union const &);
raw_key (rai::raw_key const &) = delete;
raw_key (rai::raw_key const &&) = delete;
rai::raw_key & operator = (rai::raw_key const &) = delete;
bool operator == (rai::raw_key const &) const;
bool operator != (rai::raw_key const &) const;
rai::uint256_union data;
};
union uint512_union
{
uint512_union () = default;
@ -172,6 +185,6 @@ union uint512_union
};
// Only signatures are 512 bit.
using signature = uint512_union;
rai::uint512_union sign_message (rai::private_key const &, rai::public_key const &, rai::uint256_union const &);
rai::uint512_union sign_message (rai::raw_key const &, rai::public_key const &, rai::uint256_union const &);
bool validate_message (rai::public_key const &, rai::uint256_union const &, rai::uint512_union const &);
}