diff --git a/rai/core_test/block.cpp b/rai/core_test/block.cpp index c3f060920..2f90edf31 100644 --- a/rai/core_test/block.cpp +++ b/rai/core_test/block.cpp @@ -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 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 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 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 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 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 (new rai::send_block (0, key2.pub, 200, 1, 2, 3))); + auto block (std::unique_ptr (new rai::send_block (0, key2.pub, 200, rai::keypair ().prv, 2, 3))); rai::publish req (std::move (block)); std::vector bytes; { @@ -326,7 +326,7 @@ TEST (block, confirm_req_serialization) { rai::keypair key1; rai::keypair key2; - auto block (std::unique_ptr (new rai::send_block (0, key2.pub, 200, 1, 2, 3))); + auto block (std::unique_ptr (new rai::send_block (0, key2.pub, 200, rai::keypair ().prv, 2, 3))); rai::confirm_req req (std::move (block)); std::vector bytes; { diff --git a/rai/core_test/block_store.cpp b/rai/core_test/block_store.cpp index 80d30dc6d..f55801c91 100644 --- a/rai/core_test/block_store.cpp +++ b/rai/core_test/block_store.cpp @@ -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 hashes; std::vector 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); diff --git a/rai/core_test/block_synchronization.cpp b/rai/core_test/block_synchronization.cpp index 434bfb912..41f1d11a4 100644 --- a/rai/core_test/block_synchronization.cpp +++ b/rai/core_test/block_synchronization.cpp @@ -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 > 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 > 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 > 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 > 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 > 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 > 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 > blocks; { rai::transaction transaction (store.environment, nullptr, true); diff --git a/rai/core_test/gap_cache.cpp b/rai/core_test/gap_cache.cpp index 76d40ea0f..9bfdc5c5e 100644 --- a/rai/core_test/gap_cache.cpp +++ b/rai/core_test/gap_cache.cpp @@ -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); } diff --git a/rai/core_test/ledger.cpp b/rai/core_test/ledger.cpp index cf9ccf4c0..e5cfc14a2 100644 --- a/rai/core_test/ledger.cpp +++ b/rai/core_test/ledger.cpp @@ -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); } diff --git a/rai/core_test/message.cpp b/rai/core_test/message.cpp index 95fef1d5d..d9e912271 100644 --- a/rai/core_test/message.cpp +++ b/rai/core_test/message.cpp @@ -40,7 +40,7 @@ TEST (message, keepalive_deserialize) TEST (message, publish_serialization) { - rai::publish publish (std::unique_ptr (new rai::send_block (0, 1, 2, 3, 4, 5))); + rai::publish publish (std::unique_ptr (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 (new rai::send_block (0, 1, 2, 3, 4, 5))); + rai::confirm_ack con1 (key1.pub, key1.prv, 0, std::unique_ptr (new rai::send_block (0, 1, 2, key1.prv, 4, 5))); std::vector bytes; { rai::vectorstream stream1 (bytes); diff --git a/rai/core_test/message_parser.cpp b/rai/core_test/message_parser.cpp index 6ae388707..dc73a2f13 100644 --- a/rai/core_test/message_parser.cpp +++ b/rai/core_test/message_parser.cpp @@ -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 (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 (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 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 (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1)))); + auto block (std::unique_ptr (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1)))); rai::confirm_req message (std::move (block)); std::vector 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 (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1)))); + auto block (std::unique_ptr (new rai::send_block (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1)))); rai::publish message (std::move (block)); std::vector bytes; { diff --git a/rai/core_test/network.cpp b/rai/core_test/network.cpp index b4b19729f..6da8649fd 100644 --- a/rai/core_test/network.cpp +++ b/rai/core_test/network.cpp @@ -148,7 +148,7 @@ TEST (network, multi_keepalive) TEST (network, send_discarded_publish) { rai::system system (24000, 2); - std::unique_ptr block (new rai::send_block (1, 1, 2, 3, 4, system.work.generate (1))); + std::unique_ptr 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 (node1)); frontier_req_client->pulls [rai::test_genesis_key.pub] = genesis.hash (); auto bulk_pull_client (std::make_shared (frontier_req_client)); - std::unique_ptr block1 (new rai::send_block (0, 1, 2, 3, 4, 5)); + std::unique_ptr block1 (new rai::send_block (0, 1, 2, rai::keypair ().prv, 4, 5)); bulk_pull_client->process_end (); } diff --git a/rai/core_test/node.cpp b/rai/core_test/node.cpp index fe9f1182f..640f098f4 100644 --- a/rai/core_test/node.cpp +++ b/rai/core_test/node.cpp @@ -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 ()); } diff --git a/rai/core_test/rpc.cpp b/rai/core_test/rpc.cpp index 8dea6da96..e8220ce48 100644 --- a/rai/core_test/rpc.cpp +++ b/rai/core_test/rpc.cpp @@ -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 ()); 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; diff --git a/rai/core_test/uint256_union.cpp b/rai/core_test/uint256_union.cpp index ef4298ce1..9f887090b 100644 --- a/rai/core_test/uint256_union.cpp +++ b/rai/core_test/uint256_union.cpp @@ -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); } diff --git a/rai/core_test/wallet.cpp b/rai/core_test/wallet.cpp index cdde006f4..546954c60 100644 --- a/rai/core_test/wallet.cpp +++ b/rai/core_test/wallet.cpp @@ -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); } diff --git a/rai/core_test/wallets.cpp b/rai/core_test/wallets.cpp index fbf08138d..6e5f35088 100644 --- a/rai/core_test/wallets.cpp +++ b/rai/core_test/wallets.cpp @@ -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); } } { diff --git a/rai/node/node.cpp b/rai/node/node.cpp index 99e019346..8026f111b 100644 --- a/rai/node/node.cpp +++ b/rai/node/node.cpp @@ -1140,7 +1140,7 @@ rai::uint128_t rai::gap_cache::bootstrap_threshold (MDB_txn * transaction_a) bool rai::network::confirm_broadcast (std::vector & list_a, std::unique_ptr 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 & list return result; } -void rai::network::confirm_block (rai::private_key const & prv, rai::public_key const & pub, std::unique_ptr 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 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 > bytes (new std::vector ); @@ -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 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 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 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 ()); + rai::raw_key key; + key.data.decode_hex (vm ["key"].as ()); + wallet->store.insert (transaction, key); } else { diff --git a/rai/node/node.hpp b/rai/node/node.hpp index e5b002efc..bc3a8696e 100644 --- a/rai/node/node.hpp +++ b/rai/node/node.hpp @@ -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 ); + confirm_ack (rai::account const &, rai::raw_key const &, uint64_t, std::unique_ptr ); 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 , size_t); void publish_broadcast (std::vector &, std::unique_ptr ); bool confirm_broadcast (std::vector &, std::unique_ptr , uint64_t, size_t); - void confirm_block (rai::private_key const &, rai::public_key const &, std::unique_ptr , uint64_t, rai::endpoint const &, size_t); + void confirm_block (rai::raw_key const &, rai::public_key const &, std::unique_ptr , uint64_t, rai::endpoint const &, size_t); void merge_peers (std::array const &); void send_keepalive (rai::endpoint const &); void broadcast_confirm_req (rai::block const &); diff --git a/rai/node/rpc.cpp b/rai/node/rpc.cpp index 057be5014..c5cf647af 100644 --- a/rai/node/rpc.cpp +++ b/rai/node/rpc.cpp @@ -753,8 +753,8 @@ void rai::rpc::operator () (boost::network::http::server ::request con { std::string key_text (request_l.get ("key")); std::string wallet_text (request_l.get ("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 ::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 ::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 diff --git a/rai/node/wallet.cpp b/rai/node/wallet.cpp index ff086e360..7db6baba3 100644 --- a/rai/node/wallet.cpp +++ b/rai/node/wallet.cpp @@ -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 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 const & action_a) +void rai::wallets::foreach_representative (std::function 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 first, prv)); assert (!error); action_a (j->first, prv); - prv.clear (); } else { diff --git a/rai/node/wallet.hpp b/rai/node/wallet.hpp index fd2f71231..b90a9fe6e 100644 --- a/rai/node/wallet.hpp +++ b/rai/node/wallet.hpp @@ -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 > 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 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 const &); - void foreach_representative (std::function const &); + void foreach_representative (std::function const &); std::function observer; std::unordered_map > items; std::unordered_map , std::greater >> pending_actions; diff --git a/rai/qt/qt.cpp b/rai/qt/qt.cpp index 09762552c..ccc52c2f1 100644 --- a/rai/qt/qt.cpp +++ b/rai/qt/qt.cpp @@ -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 ())); diff --git a/rai/qt_test/qt.cpp b/rai/qt_test/qt.cpp index b6af33df5..877802ef2 100644 --- a/rai/qt_test/qt.cpp +++ b/rai/qt_test/qt.cpp @@ -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 ()); diff --git a/rai/rai_node/entry.cpp b/rai/rai_node/entry.cpp index 34773aff5..eeeacb4c1 100644 --- a/rai/rai_node/entry.cpp +++ b/rai/rai_node/entry.cpp @@ -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 ::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 (end - begin).count () << std::endl; diff --git a/rai/secure.cpp b/rai/secure.cpp index feaa9491f..eb1e90b43 100644 --- a/rai/secure.cpp +++ b/rai/secure.cpp @@ -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::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 block_a) : +rai::vote::vote (rai::account const & account_a, rai::raw_key const & prv_a, uint64_t sequence_a, std::unique_ptr block_a) : sequence (sequence_a), block (std::move (block_a)), account (account_a), diff --git a/rai/secure.hpp b/rai/secure.hpp index be5613d71..e73e888f2 100644 --- a/rai/secure.hpp +++ b/rai/secure.hpp @@ -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 ); + vote (rai::account const &, rai::raw_key const &, uint64_t, std::unique_ptr ); rai::uint256_union hash () const; // Vote round sequence number uint64_t sequence; diff --git a/rai/utility.cpp b/rai/utility.cpp index d14d5aa26..7716b64af 100644 --- a/rai/utility.cpp +++ b/rai/utility.cpp @@ -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 (val_a.mv_data), reinterpret_cast (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; } diff --git a/rai/utility.hpp b/rai/utility.hpp index 0f60aab0a..bbd2e1f3d 100644 --- a/rai/utility.hpp +++ b/rai/utility.hpp @@ -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 &); } \ No newline at end of file