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) 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; std::vector <uint8_t> bytes;
{ {
rai::vectorstream stream1 (bytes); rai::vectorstream stream1 (bytes);
@ -54,7 +54,7 @@ TEST (block, send_serialize)
TEST (block, send_serialize_json) 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; std::string string1;
block1.serialize_json (string1); block1.serialize_json (string1);
ASSERT_NE (0, string1.size ()); ASSERT_NE (0, string1.size ());
@ -69,7 +69,7 @@ TEST (block, send_serialize_json)
TEST (block, receive_serialize) 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; rai::keypair key1;
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -85,7 +85,7 @@ TEST (block, receive_serialize)
TEST (block, receive_serialize_json) 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; std::string string1;
block1.serialize_json (string1); block1.serialize_json (string1);
ASSERT_NE (0, string1.size ()); ASSERT_NE (0, string1.size ());
@ -100,7 +100,7 @@ TEST (block, receive_serialize_json)
TEST (block, open_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; std::string string1;
block1.serialize_json (string1); block1.serialize_json (string1);
ASSERT_NE (0, string1.size ()); ASSERT_NE (0, string1.size ());
@ -115,7 +115,7 @@ TEST (block, open_serialize_json)
TEST (block, change_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; std::string string1;
block1.serialize_json (string1); block1.serialize_json (string1);
ASSERT_NE (0, string1.size ()); ASSERT_NE (0, string1.size ());
@ -197,7 +197,7 @@ TEST (uint512_union, parse_error_overflow)
TEST (send_block, deserialize) 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 ()); ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -214,7 +214,7 @@ TEST (send_block, deserialize)
TEST (receive_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 ()); ASSERT_EQ (block1.hash (), block1.hash ());
block1.hashables.previous = 2; block1.hashables.previous = 2;
block1.hashables.source = 4; block1.hashables.source = 4;
@ -233,7 +233,7 @@ TEST (receive_block, deserialize)
TEST (open_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 ()); ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -250,7 +250,7 @@ TEST (open_block, deserialize)
TEST (change_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 ()); ASSERT_EQ (block1.hash (), block1.hash ());
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -289,7 +289,7 @@ TEST (frontier_req, serialization)
TEST (work, one) TEST (work, one)
{ {
rai::work_pool pool; 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); pool.generate (block);
ASSERT_FALSE (pool.work_validate (block)); ASSERT_FALSE (pool.work_validate (block));
} }
@ -297,7 +297,7 @@ TEST (work, one)
TEST (work, validate) TEST (work, validate)
{ {
rai::work_pool pool; 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)); ASSERT_TRUE (pool.work_validate (send_block));
pool.generate (send_block); pool.generate (send_block);
ASSERT_FALSE (pool.work_validate (send_block)); ASSERT_FALSE (pool.work_validate (send_block));
@ -307,7 +307,7 @@ TEST (block, publish_req_serialization)
{ {
rai::keypair key1; rai::keypair key1;
rai::keypair key2; 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)); rai::publish req (std::move (block));
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -326,7 +326,7 @@ TEST (block, confirm_req_serialization)
{ {
rai::keypair key1; rai::keypair key1;
rai::keypair key2; 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)); rai::confirm_req req (std::move (block));
std::vector <uint8_t> bytes; 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); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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::uint256_union hash1 (block.hash ());
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
auto latest1 (store.block_get (transaction, hash1)); 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 ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); ASSERT_TRUE (!init);
rai::keypair key1; 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 ()); rai::uint256_union hash1 (block.hash ());
block.signature = rai::sign_message (key1.prv, key1.pub, hash1); block.signature = rai::sign_message (key1.prv, key1.pub, hash1);
rai::transaction transaction (store.environment, nullptr, true); 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 ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); ASSERT_TRUE (!init);
rai::keypair key1; 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 ()); rai::uint256_union hash1 (block.hash ());
block.signature = rai::sign_message (key1.prv, key1.pub, hash1); block.signature = rai::sign_message (key1.prv, key1.pub, hash1);
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
auto latest1 (store.block_get (transaction, hash1)); auto latest1 (store.block_get (transaction, hash1));
ASSERT_EQ (nullptr, latest1); 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; block2.hashables.account = 3;
rai::uint256_union hash2 (block2.hash ()); rai::uint256_union hash2 (block2.hash ());
block2.signature = rai::sign_message (key1.prv, key1.pub, hash2); block2.signature = rai::sign_message (key1.prv, key1.pub, hash2);
@ -88,10 +88,10 @@ TEST (block_store, add_receive)
ASSERT_TRUE (!init); ASSERT_TRUE (!init);
rai::keypair key1; rai::keypair key1;
rai::keypair key2; 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); rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, block1.hash (), block1); 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 ()); rai::block_hash hash1 (block.hash ());
auto latest1 (store.block_get (transaction, hash1)); auto latest1 (store.block_get (transaction, hash1));
ASSERT_EQ (nullptr, latest1); ASSERT_EQ (nullptr, latest1);
@ -155,7 +155,7 @@ TEST (block_store, genesis)
ASSERT_LE (info.modified, store.now ()); ASSERT_LE (info.modified, store.now ());
auto test_pub_text (rai::test_genesis_key.pub.to_string ()); auto test_pub_text (rai::test_genesis_key.pub.to_string ());
auto test_pub_account (rai::test_genesis_key.pub.to_base58check ()); 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); ASSERT_EQ (rai::genesis_account, rai::test_genesis_key.pub);
} }
@ -178,7 +178,7 @@ TEST (bootstrap, simple)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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); rai::transaction transaction (store.environment, nullptr, true);
auto block2 (store.unchecked_get (transaction, block1.previous ())); auto block2 (store.unchecked_get (transaction, block1.previous ()));
ASSERT_EQ (nullptr, block2); ASSERT_EQ (nullptr, block2);
@ -225,7 +225,7 @@ TEST (block_store, one_block)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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); rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, block1.hash (), block1); store.block_put (transaction, block1.hash (), block1);
ASSERT_TRUE (store.block_exists (transaction, block1.hash ())); ASSERT_TRUE (store.block_exists (transaction, block1.hash ()));
@ -247,7 +247,7 @@ TEST (block_store, one_bootstrap)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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); rai::transaction transaction (store.environment, nullptr, true);
store.unchecked_put (transaction, block1.hash (), block1); store.unchecked_put (transaction, block1.hash (), block1);
auto begin (store.unchecked_begin (transaction)); auto begin (store.unchecked_begin (transaction));
@ -301,7 +301,7 @@ TEST (block_store, two_block)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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; block1.hashables.account = 1;
std::vector <rai::block_hash> hashes; std::vector <rai::block_hash> hashes;
std::vector <rai::open_block> blocks; std::vector <rai::open_block> blocks;
@ -309,7 +309,7 @@ TEST (block_store, two_block)
blocks.push_back (block1); blocks.push_back (block1);
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, hashes [0], block1); 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 ()); hashes.push_back (block2.hash ());
blocks.push_back (block2); blocks.push_back (block2);
store.block_put (transaction, hashes [1], block2); store.block_put (transaction, hashes [1], block2);
@ -395,13 +395,13 @@ TEST (block_store, roots)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); 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 ()); 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 ()); 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 ()); 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 ()); ASSERT_EQ (open_block.hashables.account, open_block.root ());
} }
@ -532,8 +532,8 @@ TEST (block_store, block_replace)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init); ASSERT_TRUE (!init);
rai::send_block send1 (0, 0, 0, 0, 0, 1); rai::send_block send1 (0, 0, 0, rai::keypair ().prv, 0, 1);
rai::send_block send2 (0, 0, 0, 0, 0, 2); rai::send_block send2 (0, 0, 0, rai::keypair ().prv, 0, 2);
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
store.block_put (transaction, 0, send1); store.block_put (transaction, 0, send1);
store.block_put (transaction, 0, send2); 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); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -44,9 +44,9 @@ TEST (pull_synchronization, send_dependencies)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::send_block block3 (block2.hash (), 0, 1, 2, 3, 4); rai::send_block block3 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -71,9 +71,9 @@ TEST (pull_synchronization, change_dependencies)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::change_block block3 (block2.hash (), 0, 1, 2, 3); rai::change_block block3 (block2.hash (), 0, rai::keypair ().prv, 2, 3);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -98,9 +98,9 @@ TEST (pull_synchronization, open_dependencies)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5); rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -125,11 +125,11 @@ TEST (pull_synchronization, receive_dependencies)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5); rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
rai::send_block block4 (block2.hash (), 0, 1, 2, 3, 4); rai::send_block block4 (block2.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block5 (block3.hash (), block4.hash (), 0, 0, 0); rai::receive_block block5 (block3.hash (), block4.hash (), rai::keypair ().prv, 0, 0);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -158,13 +158,13 @@ TEST (pull_synchronization, ladder_dependencies)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::open_block block3 (block2.hash (), 1, 1, 3, 4, 5); rai::open_block block3 (block2.hash (), 1, 1, rai::keypair ().prv, 4, 5);
rai::send_block block4 (block3.hash (), 0, 1, 2, 3, 4); rai::send_block block4 (block3.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block5 (block2.hash (), block4.hash (), 0, 0, 0); rai::receive_block block5 (block2.hash (), block4.hash (), rai::keypair ().prv, 0, 0);
rai::send_block block6 (block5.hash (), 0, 1, 2, 3, 4); rai::send_block block6 (block5.hash (), 0, 1, rai::keypair ().prv, 3, 4);
rai::receive_block block7 (block4.hash (), block6.hash (), 0, 0, 0); rai::receive_block block7 (block4.hash (), block6.hash (), rai::keypair ().prv, 0, 0);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); rai::transaction transaction (store.environment, nullptr, true);
@ -211,8 +211,8 @@ TEST (push_synchronization, one)
bool init (false); bool init (false);
rai::block_store store (init, rai::unique_path ()); rai::block_store store (init, rai::unique_path ());
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::open_block block1 (0, 1, 2, 3, 4, 5); rai::open_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5);
rai::send_block block2 (block1.hash (), 0, 1, 2, 3, 4); rai::send_block block2 (block1.hash (), 0, 1, rai::keypair ().prv, 3, 4);
std::vector <std::unique_ptr <rai::block>> blocks; std::vector <std::unique_ptr <rai::block>> blocks;
{ {
rai::transaction transaction (store.environment, nullptr, true); 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::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]); 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 ()); cache.add (rai::send_block (block1), block1.previous ());
ASSERT_NE (cache.blocks.end (), cache.blocks.find (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::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]); 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 ()); auto previous (block1.previous ());
cache.add (block1, previous); cache.add (block1, previous);
auto existing1 (cache.blocks.find (previous)); auto existing1 (cache.blocks.find (previous));
@ -32,14 +32,14 @@ TEST (gap_cache, comparison)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
rai::gap_cache cache (*system.nodes [0]); 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 ()); auto previous1 (block1.previous ());
cache.add (rai::send_block (block1), previous1); cache.add (rai::send_block (block1), previous1);
auto existing1 (cache.blocks.find (previous1)); auto existing1 (cache.blocks.find (previous1));
ASSERT_NE (cache.blocks.end (), existing1); ASSERT_NE (cache.blocks.end (), existing1);
auto arrival (existing1->arrival); auto arrival (existing1->arrival);
while (std::chrono::system_clock::now () == 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 ()); auto previous2 (block3.previous ());
cache.add (rai::send_block (block3), previous2); cache.add (rai::send_block (block3), previous2);
ASSERT_EQ (2, cache.blocks.size ()); ASSERT_EQ (2, cache.blocks.size ());
@ -55,7 +55,7 @@ TEST (gap_cache, limit)
rai::gap_cache cache (*system.nodes [0]); rai::gap_cache cache (*system.nodes [0]);
for (auto i (0); i < cache.max * 2; ++i) 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 ()); auto previous (block1.previous ());
cache.add (rai::send_block (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); 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); 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); 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); 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); auto votes1 (node1.conflicts.roots.find (send1.root ())->second);
ASSERT_NE (nullptr, votes1); ASSERT_NE (nullptr, votes1);
ASSERT_EQ (1, votes1->votes.rep_votes.size ()); 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); votes1->vote (vote1);
ASSERT_EQ (1, votes1->votes.rep_votes.size ()); 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); rai::transaction transaction (store.environment, nullptr, true);
genesis.initialize (transaction, store); genesis.initialize (transaction, store);
rai::keypair key1; 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)); auto result1 (ledger.process (transaction, block));
ASSERT_EQ (rai::process_result::bad_signature, result1.code); 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); rai::transaction transaction (store.environment, nullptr, true);
genesis.initialize (transaction, store); genesis.initialize (transaction, store);
rai::keypair key1; 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)); auto result1 (ledger.process (transaction, block));
ASSERT_EQ (rai::process_result::bad_signature, result1.code); 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); rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0);
auto result3 (ledger.process (transaction, block3)); auto result3 (ledger.process (transaction, block3));
ASSERT_EQ (rai::process_result::progress, result3.code); 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)); auto result4 (ledger.process (transaction, block4));
ASSERT_EQ (rai::process_result::bad_signature, result4.code); 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) 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_EQ (rai::block_type::send, publish.block_type ());
ASSERT_FALSE (publish.ipv4_only ()); ASSERT_FALSE (publish.ipv4_only ());
publish.ipv4_only_set (true); publish.ipv4_only_set (true);
@ -75,7 +75,7 @@ TEST (message, publish_serialization)
TEST (message, confirm_ack_serialization) TEST (message, confirm_ack_serialization)
{ {
rai::keypair key1; 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; std::vector <uint8_t> bytes;
{ {
rai::vectorstream stream1 (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); rai::system system (24000, 1);
test_visitor visitor; test_visitor visitor;
rai::message_parser parser (visitor, system.work); 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_ack message (0, 0, 0, std::move (block)); rai::confirm_ack message (0, rai::keypair ().prv, 0, std::move (block));
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
rai::vectorstream stream (bytes); rai::vectorstream stream (bytes);
@ -81,7 +81,7 @@ TEST (message_parser, exact_confirm_req_size)
rai::system system (24000, 1); rai::system system (24000, 1);
test_visitor visitor; test_visitor visitor;
rai::message_parser parser (visitor, system.work); 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)); rai::confirm_req message (std::move (block));
std::vector <uint8_t> bytes; std::vector <uint8_t> bytes;
{ {
@ -104,7 +104,7 @@ TEST (message_parser, exact_publish_size)
rai::system system (24000, 1); rai::system system (24000, 1);
test_visitor visitor; test_visitor visitor;
rai::message_parser parser (visitor, system.work); 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)); rai::publish message (std::move (block));
std::vector <uint8_t> bytes; 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) TEST (network, send_discarded_publish)
{ {
rai::system system (24000, 2); 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); system.nodes [0]->network.republish_block (std::move (block), 0);
rai::genesis genesis; rai::genesis genesis;
ASSERT_EQ (genesis.hash (), system.nodes [0]->latest (rai::test_genesis_key.pub)); 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); 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 ()); 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::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.account = key2.pub;
open.hashables.representative = key2.pub; open.hashables.representative = key2.pub;
open.hashables.source = latest; 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)); auto frontier_req_client (std::make_shared <rai::frontier_req_client> (node1));
frontier_req_client->pulls [rai::test_genesis_key.pub] = genesis.hash (); 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)); 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 (); 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::system system (24000, 1);
rai::keypair key2; rai::keypair key2;
system.wallet (0)->insert (rai::test_genesis_key.prv); 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 ()); 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); rai::system system (24000, 1);
auto & node1 (*system.nodes [0]); auto & node1 (*system.nodes [0]);
ASSERT_EQ (0, node1.gap_cache.blocks.size ()); 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; rai::confirm_req message;
message.block = block.clone (); message.block = block.clone ();
node1.process_message (message, node1.network.endpoint ()); node1.process_message (message, node1.network.endpoint ());
@ -299,7 +299,7 @@ TEST (node, unlock_search)
ASSERT_LT (iterations1, 200); ASSERT_LT (iterations1, 200);
} }
system.wallet (0)->insert (key2.prv); 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]); auto node (system.nodes [0]);
ASSERT_FALSE (system.wallet (0)->enter_password ("")); ASSERT_FALSE (system.wallet (0)->enter_password (""));
auto iterations2 (0); auto iterations2 (0);
@ -427,7 +427,7 @@ TEST (node, confirm_locked)
rai::system system (24000, 1); rai::system system (24000, 1);
system.wallet (0)->insert (rai::test_genesis_key.prv); system.wallet (0)->insert (rai::test_genesis_key.prv);
system.wallet (0)->enter_password ("1"); 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 ()); 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::rpc rpc (system.service, pool, *system.nodes [0], rai::rpc_config (true));
rai::keypair key1; rai::keypair key1;
std::string key_text; std::string key_text;
key1.prv.encode_hex (key_text); key1.prv.data.encode_hex (key_text);
system.wallet (0)->insert (key1.prv); system.wallet (0)->insert (key1.prv);
boost::property_tree::ptree request; boost::property_tree::ptree request;
std::string wallet; std::string wallet;
@ -247,11 +247,14 @@ TEST (rpc, wallet_password_enter)
{ {
rai::system system (24000, 1); rai::system system (24000, 1);
auto iterations (0); 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 (); system.poll ();
++iterations; ++iterations;
ASSERT_LT (iterations, 200); ASSERT_LT (iterations, 200);
system.wallet (0)->store.password.value (password_l);
} }
auto pool (boost::make_shared <boost::network::utils::thread_pool> ()); auto pool (boost::make_shared <boost::network::utils::thread_pool> ());
rai::rpc rpc (system.service, pool, *system.nodes [0], rai::rpc_config (true)); rai::rpc rpc (system.service, pool, *system.nodes [0], rai::rpc_config (true));
@ -409,12 +412,12 @@ TEST (rpc, account_move)
rai::keypair key; rai::keypair key;
destination->insert (rai::test_genesis_key.prv); destination->insert (rai::test_genesis_key.prv);
rai::keypair source_id; 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); source->insert (key.prv);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "account_move"); request.put ("action", "account_move");
request.put ("wallet", wallet_id.to_string ()); 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 keys;
boost::property_tree::ptree entry; boost::property_tree::ptree entry;
entry.put ("", key.pub.to_string ()); entry.put ("", key.pub.to_string ());
@ -568,8 +571,8 @@ TEST (rpc, frontier)
for (auto i (0); i < 1000; ++i) for (auto i (0); i < 1000; ++i)
{ {
rai::keypair key; rai::keypair key;
source [key.pub] = key.prv; source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0)); system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
} }
} }
rai::keypair key; rai::keypair key;
@ -604,8 +607,8 @@ TEST (rpc, frontier_limited)
for (auto i (0); i < 1000; ++i) for (auto i (0); i < 1000; ++i)
{ {
rai::keypair key; rai::keypair key;
source [key.pub] = key.prv; source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0)); system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
} }
} }
rai::keypair key; rai::keypair key;
@ -630,8 +633,8 @@ TEST (rpc, frontier_startpoint)
for (auto i (0); i < 1000; ++i) for (auto i (0); i < 1000; ++i)
{ {
rai::keypair key; rai::keypair key;
source [key.pub] = key.prv; source [key.pub] = key.prv.data;
system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv, 0, 0, 0)); system.nodes [0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0));
} }
} }
rai::keypair key; rai::keypair key;

27
rai/core_test/uint256_union.cpp
View file

@ -22,24 +22,31 @@ TEST (unions, identity)
TEST (uint256_union, key_encryption) TEST (uint256_union, key_encryption)
{ {
rai::keypair key1; rai::keypair key1;
rai::uint256_union secret_key; rai::raw_key secret_key;
secret_key.bytes.fill (0); secret_key.data.bytes.fill (0);
rai::uint256_union encrypted (key1.prv, secret_key, key1.pub.owords [0]); rai::uint256_union encrypted;
rai::private_key key4 (encrypted.prv (secret_key, key1.pub.owords [0])); 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); ASSERT_EQ (key1.prv, key4);
rai::public_key pub; 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); ASSERT_EQ (key1.pub, pub);
} }
TEST (uint256_union, encryption) TEST (uint256_union, encryption)
{ {
rai::uint256_union key (0); rai::raw_key key;
rai::uint256_union number1 (1); key.data.clear ();
rai::uint256_union encrypted1 (number1, key, key.owords [0]); rai::raw_key number1;
rai::uint256_union encrypted2 (number1, key, key.owords [0]); 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); 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); 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"); rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init); ASSERT_FALSE (init);
rai::keypair key1; rai::keypair key1;
rai::private_key prv1; rai::raw_key prv1;
ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv1)); ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv1));
ASSERT_TRUE (wallet.valid_password (transaction)); ASSERT_TRUE (wallet.valid_password (transaction));
} }
@ -30,12 +30,12 @@ TEST (wallet, retrieval)
rai::keypair key1; rai::keypair key1;
ASSERT_TRUE (wallet.valid_password (transaction)); ASSERT_TRUE (wallet.valid_password (transaction));
wallet.insert (transaction, key1.prv); wallet.insert (transaction, key1.prv);
rai::private_key prv1; rai::raw_key prv1;
ASSERT_FALSE (wallet.fetch (transaction, key1.pub, prv1)); ASSERT_FALSE (wallet.fetch (transaction, key1.pub, prv1));
ASSERT_TRUE (wallet.valid_password (transaction)); ASSERT_TRUE (wallet.valid_password (transaction));
ASSERT_EQ (key1.prv, prv1); ASSERT_EQ (key1.prv, prv1);
wallet.password.values [0]->bytes [16] ^= 1; wallet.password.values [0]->bytes [16] ^= 1;
rai::private_key prv2; rai::raw_key prv2;
ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv2)); ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv2));
ASSERT_FALSE (wallet.valid_password (transaction)); 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) for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i)
{ {
ASSERT_EQ (key1.pub, i->first); 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) for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i)
{ {
pubs.insert (i->first); 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, pubs.size ());
ASSERT_EQ (2, prvs.size ()); ASSERT_EQ (2, prvs.size ());
ASSERT_NE (pubs.end (), pubs.find (key1.pub)); 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 (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) TEST (wallet, insufficient_spend_one)
@ -238,16 +246,21 @@ TEST (wallet, rekey)
rai::kdf kdf; rai::kdf kdf;
rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0"); rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init); 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); ASSERT_FALSE (init);
rai::keypair key1; rai::keypair key1;
wallet.insert (transaction, key1.prv); wallet.insert (transaction, key1.prv);
rai::uint256_union prv1; rai::raw_key prv1;
wallet.fetch (transaction, key1.pub, prv1); wallet.fetch (transaction, key1.pub, prv1);
ASSERT_EQ (key1.prv, prv1); ASSERT_EQ (key1.prv, prv1);
ASSERT_FALSE (wallet.rekey (transaction, "1")); ASSERT_FALSE (wallet.rekey (transaction, "1"));
ASSERT_EQ (wallet.derive_key (transaction, "1"), wallet.password.value ()); wallet.password.value (password);
rai::uint256_union prv2; rai::raw_key password1;
wallet.derive_key (password1, transaction, "1");
ASSERT_EQ (password1, password);
rai::raw_key prv2;
wallet.fetch (transaction, key1.pub, prv2); wallet.fetch (transaction, key1.pub, prv2);
ASSERT_EQ (key1.prv, prv2); ASSERT_EQ (key1.prv, prv2);
*wallet.password.values [0] = 2; *wallet.password.values [0] = 2;
@ -296,10 +309,13 @@ TEST (wallet, hash_password)
rai::kdf kdf; rai::kdf kdf;
rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0"); rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, "0");
ASSERT_FALSE (init); ASSERT_FALSE (init);
auto hash1 (wallet.derive_key (transaction, "")); rai::raw_key hash1;
auto hash2 (wallet.derive_key (transaction, "")); wallet.derive_key (hash1, transaction, "");
rai::raw_key hash2;
wallet.derive_key (hash2, transaction, "");
ASSERT_EQ (hash1, hash2); 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); ASSERT_NE (hash1, hash3);
} }
@ -311,19 +327,25 @@ TEST (fan, reconstitute)
{ {
ASSERT_NE (value0, *i); ASSERT_NE (value0, *i);
} }
auto value1 (fan.value ()); rai::raw_key value1;
ASSERT_EQ (value0, value1); fan.value (value1);
ASSERT_EQ (value0, value1.data);
} }
TEST (fan, change) TEST (fan, change)
{ {
rai::uint256_union value0 (0); rai::raw_key value0;
rai::uint256_union value1 (1); value0.data = 0;
rai::raw_key value1;
value1.data = 1;
ASSERT_NE (value0, value1); ASSERT_NE (value0, value1);
rai::fan fan (value0, 1024); rai::fan fan (value0.data, 1024);
ASSERT_EQ (value0, fan.value ()); rai::raw_key value2;
fan.value (value2);
ASSERT_EQ (value0, value2);
fan.value_set (value1); fan.value_set (value1);
ASSERT_EQ (value1, fan.value ()); fan.value (value2);
ASSERT_EQ (value1, value2);
} }
TEST (wallet, reopen_default_password) TEST (wallet, reopen_default_password)
@ -396,7 +418,11 @@ TEST (wallet, serialize_json_empty)
wallet1.serialize_json (transaction, serialized); wallet1.serialize_json (transaction, serialized);
rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized); rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized);
ASSERT_FALSE (error); 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.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction)); ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction)); ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
@ -419,12 +445,16 @@ TEST (wallet, serialize_json_one)
wallet1.serialize_json (transaction, serialized); wallet1.serialize_json (transaction, serialized);
rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized); rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, "1", serialized);
ASSERT_FALSE (error); 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.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction)); ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction)); ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
ASSERT_TRUE (wallet2.exists (transaction, key.pub)); ASSERT_TRUE (wallet2.exists (transaction, key.pub));
rai::private_key prv; rai::raw_key prv;
wallet2.fetch (transaction, key.pub, prv); wallet2.fetch (transaction, key.pub, prv);
ASSERT_EQ (key.prv, prv); ASSERT_EQ (key.prv, prv);
} }
@ -448,12 +478,16 @@ TEST (wallet, serialize_json_password)
ASSERT_FALSE (wallet2.valid_password (transaction)); ASSERT_FALSE (wallet2.valid_password (transaction));
ASSERT_FALSE (wallet2.attempt_password (transaction, "password")); ASSERT_FALSE (wallet2.attempt_password (transaction, "password"));
ASSERT_TRUE (wallet2.valid_password (transaction)); 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.salt (transaction), wallet2.salt (transaction));
ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction)); ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction));
ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction)); ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction));
ASSERT_TRUE (wallet2.exists (transaction, key.pub)); ASSERT_TRUE (wallet2.exists (transaction, key.pub));
rai::private_key prv; rai::raw_key prv;
wallet2.fetch (transaction, key.pub, prv); wallet2.fetch (transaction, key.pub, prv);
ASSERT_EQ (key.prv, 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_NE (nullptr, wallet);
ASSERT_EQ (wallet, wallets.open (id)); ASSERT_EQ (wallet, wallets.open (id));
auto iterations (0); auto iterations (0);
while (wallet->store.password.value () == 0) rai::raw_key password;
password.data.clear ();
while (password.data == 0)
{ {
system.poll (); system.poll ();
++iterations; ++iterations;
ASSERT_LT (iterations, 200); 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 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); 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 ()); auto hash (block_a->hash ());
for (auto j (list_a.begin ()), m (list_a.end ()); j != m; ++j) 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; 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)); 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>); 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) 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 ()) 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), message (rai::message_type::confirm_ack),
vote (account_a, prv_a, sequence_a, std::move (block_a)) 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) if (is_representative)
{ {
auto representative (i->second->store.representative (transaction)); auto representative (i->second->store.representative (transaction));
rai::private_key prv; rai::raw_key prv;
auto error (i->second->store.fetch (transaction, representative, prv)); auto error (i->second->store.fetch (transaction, representative, prv));
(void)error; (void)error;
vote_l = rai::vote (representative, prv, 0, block_a.clone ()); vote_l = rai::vote (representative, prv, 0, block_a.clone ());
prv.clear ();
result = true; result = true;
} }
} }
@ -3901,22 +3900,21 @@ rai::fan::fan (rai::uint256_union const & key, size_t count_a)
values.push_back (std::move (first)); 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; prv_a.data.clear ();
result.clear ();
for (auto & i: values) 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 ()); rai::raw_key value_l;
*(values [0]) ^= value_l; value (value_l);
*(values [0]) ^= value_a; *(values [0]) ^= value_l.data;
*(values [0]) ^= value_a.data;
} }
std::array <uint8_t, 2> constexpr rai::message::magic_number; 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")) else if (vm.count ("diagnostics"))
{ {
std::cout << "Testing hash function" << std::endl; 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 ()); auto hash (send.hash ());
std::cout << "Testing key derivation function" << std::endl; 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::uint256_union junk2 (0);
rai::kdf kdf; rai::kdf kdf;
kdf.phs (junk1, "", junk2); 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")) else if (vm.count ("key_create"))
{ {
rai::keypair pair; 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")) 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)) if (!wallet->enter_password (password))
{ {
rai::transaction transaction (wallet->store.environment, nullptr, true); 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 else
{ {

4
rai/node/node.hpp
View file

@ -207,7 +207,7 @@ class confirm_ack : public message
{ {
public: public:
confirm_ack (bool &, rai::stream &); 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; bool deserialize (rai::stream &) override;
void serialize (rai::stream &) override; void serialize (rai::stream &) override;
void visit (rai::message_visitor &) const override; void visit (rai::message_visitor &) const override;
@ -489,7 +489,7 @@ public:
void republish_block (std::unique_ptr <rai::block>, size_t); void republish_block (std::unique_ptr <rai::block>, size_t);
void publish_broadcast (std::vector <rai::peer_information> &, std::unique_ptr <rai::block>); 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); 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 merge_peers (std::array <rai::endpoint, 8> const &);
void send_keepalive (rai::endpoint const &); void send_keepalive (rai::endpoint const &);
void broadcast_confirm_req (rai::block 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 key_text (request_l.get <std::string> ("key"));
std::string wallet_text (request_l.get <std::string> ("wallet")); std::string wallet_text (request_l.get <std::string> ("wallet"));
rai::private_key key; rai::raw_key key;
auto error (key.decode_hex (key_text)); auto error (key.data.decode_hex (key_text));
if (!error) if (!error)
{ {
rai::uint256_union wallet; 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); rai::transaction transaction (node.store.environment, nullptr, true);
existing->second->store.insert (transaction, key); existing->second->store.insert (transaction, key);
rai::public_key pub; 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; boost::property_tree::ptree response_l;
response_l.put ("account", pub.to_base58check ()); response_l.put ("account", pub.to_base58check ());
set_response (response, response_l); 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) if (config.enable_control)
{ {
rai::keypair wallet_id; 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; 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); set_response (response, response_l);
} }
else 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; 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)); rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::wallet_key_special));
auto password_l (password.value ()); rai::raw_key password_l;
auto result (value.key.prv (password_l, salt (transaction_a).owords [0])); password.value (password_l);
password_l.clear (); prv_a.decrypt (value.key, password_l, salt (transaction_a).owords [0]);
return result;
} }
bool rai::wallet_store::valid_password (MDB_txn * transaction_a) bool rai::wallet_store::valid_password (MDB_txn * transaction_a)
{ {
rai::uint256_union zero; rai::raw_key zero;
zero.clear (); zero.data.clear ();
auto wallet_key_l (wallet_key (transaction_a)); rai::raw_key wallet_key_l;
rai::uint256_union check_l (zero, wallet_key_l, salt (transaction_a).owords [0]); wallet_key (wallet_key_l, transaction_a);
wallet_key_l.clear (); rai::uint256_union check_l;
check_l.encrypt (zero, wallet_key_l, salt (transaction_a).owords [0]);
return check (transaction_a) == check_l; return check (transaction_a) == check_l;
} }
bool rai::wallet_store::attempt_password (MDB_txn * transaction_a, std::string const & password_a) 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)); auto result (!valid_password (transaction_a));
return result; return result;
} }
@ -217,14 +219,17 @@ bool rai::wallet_store::rekey (MDB_txn * transaction_a, std::string const & pass
bool result (false); bool result (false);
if (valid_password (transaction_a)) if (valid_password (transaction_a))
{ {
auto password_new (derive_key (transaction_a, password_a)); rai::raw_key password_new;
auto wallet_key_l (wallet_key (transaction_a)); derive_key (password_new, transaction_a, password_a);
auto password_l (password.value ()); rai::raw_key wallet_key_l;
(*password.values [0]) ^= password_l; wallet_key (wallet_key_l, transaction_a);
(*password.values [0]) ^= password_new; rai::raw_key password_l;
rai::uint256_union encrypted (wallet_key_l, password_new, salt (transaction_a).owords [0]); 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)); entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted));
wallet_key_l.clear ();
} }
else else
{ {
@ -233,12 +238,10 @@ bool rai::wallet_store::rekey (MDB_txn * transaction_a, std::string const & pass
return result; 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)); auto salt_l (salt (transaction_a));
kdf.phs (result, password_a, salt_l); kdf.phs (prv_a, password_a, salt_l);
return result;
} }
rai::wallet_value::wallet_value (MDB_val const & val_a) 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, 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, check_special.val (), &junk) != 0;
init_a = init_a || mdb_get (transaction_a, handle, representative_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 ()); 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)); 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 // Wallet key is a fixed random key that encrypts all entries
rai::uint256_union wallet_key; rai::raw_key wallet_key;
random_pool.GenerateBlock (wallet_key.bytes.data (), sizeof (wallet_key.bytes)); random_pool.GenerateBlock (wallet_key.data.bytes.data (), sizeof (wallet_key.data.bytes));
password.value_set (0); 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 // 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)); entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted));
rai::uint256_union zero (0); rai::uint256_union check;
rai::uint256_union check (zero, wallet_key, salt_l.owords [0]); check.encrypt (zero, wallet_key, salt_l.owords [0]);
entry_put_raw (transaction_a, rai::wallet_store::check_special, rai::wallet_value (check)); 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)); 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; 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; rai::public_key pub;
ed25519_publickey (prv.bytes.data (), pub.bytes.data ()); ed25519_publickey (prv.data.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]))); 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; return pub;
} }
@ -419,15 +432,17 @@ void rai::wallet_store::entry_put_raw (MDB_txn * transaction_a, rai::public_key
assert (status == 0); 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); auto result (false);
rai::wallet_value value (entry_get_raw (transaction_a, pub)); rai::wallet_value value (entry_get_raw (transaction_a, pub));
if (!value.key.is_zero ()) 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; rai::public_key compare;
ed25519_publickey (prv.bytes.data (), compare.bytes.data ()); ed25519_publickey (prv.data.bytes.data (), compare.bytes.data ());
if (!(pub == compare)) if (!(pub == compare))
{ {
result = true; result = true;
@ -476,7 +491,7 @@ bool rai::wallet_store::move (MDB_txn * transaction_a, rai::wallet_store & other
auto result (false); auto result (false);
for (auto i (keys.begin ()), n (keys.end ()); i != n; ++i) 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)); auto error (other_a.fetch (transaction_a, *i, prv));
result = result | error; result = result | error;
if (!result) if (!result)
@ -495,7 +510,7 @@ bool rai::wallet_store::import (MDB_txn * transaction_a, rai::wallet_store & oth
auto result (false); auto result (false);
for (auto i (other_a.begin (transaction_a)), n (end ()); i != n; ++i) 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)); auto error (other_a.fetch (transaction_a, i->first, prv));
result = result | error; result = result | error;
if (!result) 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); 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); 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; assert (success == 0); (void) success;
} }
@ -553,7 +568,9 @@ node (node_a)
void rai::wallet::enter_initial_password () 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 ()) if (valid_password ())
{ {
@ -588,7 +605,7 @@ bool rai::wallet::enter_password (std::string const & password_a)
return result; 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::block_hash root;
rai::public_key key; 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); rai::transaction transaction (node.ledger.store.environment, nullptr, false);
if (node.ledger.store.pending_exists (transaction, hash)) 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)) if (!store.fetch (transaction, send_a.hashables.destination, prv))
{ {
rai::account_info info; rai::account_info info;
@ -681,7 +698,6 @@ bool rai::wallet::receive_action (rai::send_block const & send_a, rai::account c
result = true; result = true;
BOOST_LOG (node.log) << "Unable to receive, wallet locked"; BOOST_LOG (node.log) << "Unable to receive, wallet locked";
} }
prv.clear ();
} }
else else
{ {
@ -722,11 +738,10 @@ bool rai::wallet::change_action (rai::account const & source_a, rai::account con
rai::account_info info; rai::account_info info;
result = node.ledger.store.account_get (transaction, source_a, info); result = node.ledger.store.account_get (transaction, source_a, info);
assert (!result); assert (!result);
rai::private_key prv; rai::raw_key prv;
result = store.fetch (transaction, source_a, prv); result = store.fetch (transaction, source_a, prv);
assert (!result); assert (!result);
block.reset (new rai::change_block (info.head, representative_a, prv, source_a, work_fetch (transaction, source_a, info.head))); block.reset (new rai::change_block (info.head, representative_a, prv, source_a, work_fetch (transaction, source_a, info.head)));
prv.clear ();
} }
else else
{ {
@ -769,11 +784,10 @@ rai::block_hash rai::wallet::send_action (rai::account const & source_a, rai::ac
rai::account_info info; rai::account_info info;
result = node.ledger.store.account_get (transaction, source_a, info); result = node.ledger.store.account_get (transaction, source_a, info);
assert (!result); assert (!result);
rai::private_key prv; rai::raw_key prv;
result = store.fetch (transaction, source_a, prv); result = store.fetch (transaction, source_a, prv);
assert (!result); 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))); 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 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) 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)) if (wallet.store.valid_password (transaction))
{ {
rai::private_key prv; rai::raw_key prv;
auto error (wallet.store.fetch (transaction, j->first, prv)); auto error (wallet.store.fetch (transaction, j->first, prv));
assert (!error); assert (!error);
action_a (j->first, prv); action_a (j->first, prv);
prv.clear ();
} }
else else
{ {

18
rai/node/wallet.hpp
View file

@ -41,8 +41,8 @@ class fan
{ {
public: public:
fan (rai::uint256_union const &, size_t); fan (rai::uint256_union const &, size_t);
rai::uint256_union value (); void value (rai::raw_key &);
void value_set (rai::uint256_union const &); void value_set (rai::raw_key const &);
std::vector <std::unique_ptr <rai::uint256_union>> values; std::vector <std::unique_ptr <rai::uint256_union>> values;
}; };
class wallet_value class wallet_value
@ -59,7 +59,7 @@ class node_config;
class kdf class kdf
{ {
public: 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; std::mutex mutex;
}; };
class wallet_store class wallet_store
@ -73,22 +73,22 @@ public:
bool rekey (MDB_txn *, std::string const &); bool rekey (MDB_txn *, std::string const &);
bool valid_password (MDB_txn *); bool valid_password (MDB_txn *);
bool attempt_password (MDB_txn *, std::string const &); 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 *); rai::uint256_union salt (MDB_txn *);
bool is_representative (MDB_txn *); bool is_representative (MDB_txn *);
rai::account representative (MDB_txn *); rai::account representative (MDB_txn *);
void representative_set (MDB_txn *, rai::account const &); 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 &); void erase (MDB_txn *, rai::public_key const &);
rai::wallet_value entry_get_raw (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 &); 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 &); bool exists (MDB_txn *, rai::public_key const &);
void destroy (MDB_txn *); void destroy (MDB_txn *);
rai::store_iterator find (MDB_txn *, rai::uint256_union const &); rai::store_iterator find (MDB_txn *, rai::uint256_union const &);
rai::store_iterator begin (MDB_txn *); rai::store_iterator begin (MDB_txn *);
rai::store_iterator end (); 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 serialize_json (MDB_txn *, std::string &);
void write_backup (MDB_txn *, boost::filesystem::path const &); void write_backup (MDB_txn *, boost::filesystem::path const &);
bool move (MDB_txn *, rai::wallet_store &, std::vector <rai::public_key> const &); bool move (MDB_txn *, rai::wallet_store &, std::vector <rai::public_key> const &);
@ -121,7 +121,7 @@ public:
void enter_initial_password (); void enter_initial_password ();
bool valid_password (); bool valid_password ();
bool enter_password (std::string const &); 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 exists (rai::public_key const &);
bool import (std::string const &, std::string const &); bool import (std::string const &, std::string const &);
void serialize (std::string &); void serialize (std::string &);
@ -149,7 +149,7 @@ public:
bool search_pending (rai::uint256_union const &); bool search_pending (rai::uint256_union const &);
void destroy (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 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::function <void (rai::account const &, bool)> observer;
std::unordered_map <rai::uint256_union, std::shared_ptr <rai::wallet>> items; 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; 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 ()); QString key_text_wide (account_key_line->text ());
std::string key_text (key_text_wide.toLocal8Bit ()); std::string key_text (key_text_wide.toLocal8Bit ());
rai::private_key key; rai::raw_key key;
if (!key.decode_hex (key_text)) if (!key.data.decode_hex (key_text))
{ {
show_line_ok (*account_key_line); show_line_ok (*account_key_line);
account_key_line->clear (); account_key_line->clear ();
@ -776,8 +776,8 @@ wallet (wallet_a)
}); });
QObject::connect (lock, &QPushButton::released, [this] () QObject::connect (lock, &QPushButton::released, [this] ()
{ {
rai::uint256_union empty; rai::raw_key empty;
empty.clear (); empty.data.clear ();
wallet.wallet_m->store.password.value_set (empty); wallet.wallet_m->store.password.value_set (empty);
update_locked (true, true); update_locked (true, true);
}); });
@ -1206,7 +1206,7 @@ void rai_qt::block_creation::create_send ()
if (!error) if (!error)
{ {
rai::transaction transaction (wallet.node.store.environment, nullptr, false); 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)) if (!wallet.wallet_m->store.fetch (transaction, account_l, key))
{ {
auto balance (wallet.node.ledger.account_balance (transaction, account_l)); 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)); auto error (wallet.node.store.account_get (transaction, account_l, info));
assert (!error); 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)); 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; std::string block_l;
send.serialize_json (block_l); send.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ())); 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)); auto error (wallet.node.store.account_get (transaction, receivable.destination, info));
if (!error) if (!error)
{ {
rai::private_key key; rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key)); auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key));
if (!error) if (!error)
{ {
rai::receive_block receive (info.head, source_l, key, receivable.destination, wallet.wallet_m->work_fetch (transaction, receivable.destination, info.head)); 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; std::string block_l;
receive.serialize_json (block_l); receive.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ())); 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)); auto error (wallet.node.store.account_get (transaction, account_l, info));
if (!error) if (!error)
{ {
rai::private_key key; rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, account_l, key)); auto error (wallet.wallet_m->store.fetch (transaction, account_l, key));
if (!error) if (!error)
{ {
rai::change_block change (info.head, representative_l, key, account_l, wallet.wallet_m->work_fetch (transaction, account_l, info.head)); 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; std::string block_l;
change.serialize_json (block_l); change.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ())); 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)); auto error (wallet.node.store.account_get (transaction, receivable.destination, info));
if (error) if (error)
{ {
rai::private_key key; rai::raw_key key;
auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key)); auto error (wallet.wallet_m->store.fetch (transaction, receivable.destination, key));
if (!error) 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)); 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; std::string block_l;
open.serialize_json (block_l); open.serialize_json (block_l);
block->setPlainText (QString (block_l.c_str ())); 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); rai::system system (24000, 1);
auto wallet_l (system.nodes [0]->wallets.create (rai::uint256_union ())); auto wallet_l (system.nodes [0]->wallets.create (rai::uint256_union ()));
rai::public_key key1 (wallet_l->insert (1)); rai::public_key key1 (wallet_l->insert (rai::keypair ().prv));
rai::public_key key2 (wallet_l->insert (2)); rai::public_key key2 (wallet_l->insert (rai::keypair ().prv));
rai_qt::wallet wallet (*test_application, *system.nodes [0], wallet_l, key1); rai_qt::wallet wallet (*test_application, *system.nodes [0], wallet_l, key1);
ASSERT_EQ (key1, wallet.account); ASSERT_EQ (key1, wallet.account);
QTest::mouseClick (wallet.show_advanced, Qt::LeftButton); QTest::mouseClick (wallet.show_advanced, Qt::LeftButton);
@ -116,14 +116,22 @@ TEST (wallet, password_change)
QTest::mouseClick (wallet.settings_button, Qt::LeftButton); QTest::mouseClick (wallet.settings_button, Qt::LeftButton);
{ {
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false); 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.new_password, "1");
QTest::keyClicks (wallet.settings.retype_password, "1"); QTest::keyClicks (wallet.settings.retype_password, "1");
QTest::mouseClick (wallet.settings.change, Qt::LeftButton); QTest::mouseClick (wallet.settings.change, Qt::LeftButton);
{ {
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false); 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.new_password->text ());
ASSERT_EQ ("", wallet.settings.retype_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); rai_qt::wallet wallet (*test_application, *system.nodes [0], system.wallet (0), account);
QTest::mouseClick (wallet.settings_button, Qt::LeftButton); QTest::mouseClick (wallet.settings_button, Qt::LeftButton);
auto iterations (0); auto iterations (0);
while (system.wallet (0)->store.password.value () == 0) rai::raw_key password;
password.data.clear ();
while (password.data == 0)
{ {
system.poll (); system.poll ();
++iterations; ++iterations;
ASSERT_LT (iterations, 200); ASSERT_LT (iterations, 200);
system.wallet (0)->store.password.value (password);
} }
{ {
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false); 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.new_password, "1");
QTest::keyClicks (wallet.settings.retype_password, "2"); QTest::keyClicks (wallet.settings.retype_password, "2");
QTest::mouseClick (wallet.settings.change, Qt::LeftButton); QTest::mouseClick (wallet.settings.change, Qt::LeftButton);
{ {
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false); 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 ("1", wallet.settings.new_password->text ());
ASSERT_EQ ("", wallet.settings.retype_password->text ()); ASSERT_EQ ("", wallet.settings.retype_password->text ());
@ -198,7 +217,7 @@ TEST (wallet, send)
{ {
rai::system system (24000, 2); rai::system system (24000, 2);
system.wallet (0)->insert (rai::test_genesis_key.prv); 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); 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::mouseClick (wallet.send_blocks, Qt::LeftButton);
QTest::keyClicks (wallet.send_account, key1.to_base58check ().c_str ()); 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::keypair genesis (key.to_string ());
rai::work_pool work; 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; 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) for (auto i (0); i != 32; ++i)
{ {
rai::keypair rep; 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::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)); 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")) else if (vm.count ("debug_profile_generate"))
{ {
rai::work_pool work; 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"; std::cerr << "Starting generation profiling\n";
for (uint64_t i (0); true; ++i) 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")) else if (vm.count ("debug_profile_verify"))
{ {
rai::work_pool work; 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"; std::cerr << "Starting verification profiling\n";
for (uint64_t i (0); true; ++i) 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 ()); auto begin (std::chrono::high_resolution_clock::now ());
for (auto i (0u); i < 1000; ++i) 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 ()); auto end (std::chrono::high_resolution_clock::now ());
std::cerr << "Signature verifications " << std::chrono::duration_cast <std::chrono::microseconds> (end - begin).count () << std::endl; 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 // Create a new random keypair
rai::keypair::keypair () rai::keypair::keypair ()
{ {
random_pool.GenerateBlock (prv.bytes.data (), prv.bytes.size ()); random_pool.GenerateBlock (prv.data.bytes.data (), prv.data.bytes.size ());
ed25519_publickey (prv.bytes.data (), pub.bytes.data ()); ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ());
} }
// Create a keypair given a hex string of the private key // Create a keypair given a hex string of the private key
rai::keypair::keypair (std::string const & prv_a) 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); 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) : 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 (); 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), hashables (previous_a, source_a),
signature (rai::sign_message (prv_a, pub_a, hash())), signature (rai::sign_message (prv_a, pub_a, hash())),
work (work_a) work (work_a)
@ -708,7 +708,7 @@ std::unique_ptr <rai::block> rai::deserialize_block (rai::stream & stream_a)
return result; 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), hashables (previous_a, destination_a, balance_a),
signature (rai::sign_message (prv_a, pub_a, hash ())), signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a) 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)); 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), hashables (source_a, representative_a, account_a),
signature (rai::sign_message (prv_a, pub_a, hash ())), signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a) 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)); 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), hashables (previous_a, representative_a),
signature (rai::sign_message (prv_a, pub_a, hash ())), signature (rai::sign_message (prv_a, pub_a, hash ())),
work (work_a) 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), sequence (sequence_a),
block (std::move (block_a)), block (std::move (block_a)),
account (account_a), account (account_a),

12
rai/secure.hpp
View file

@ -45,7 +45,7 @@ public:
keypair (); keypair ();
keypair (std::string const &); keypair (std::string const &);
rai::public_key pub; rai::public_key pub;
rai::private_key prv; rai::raw_key prv;
}; };
class block_visitor; class block_visitor;
enum class block_type : uint8_t enum class block_type : uint8_t
@ -105,7 +105,7 @@ public:
class send_block : public rai::block class send_block : public rai::block
{ {
public: 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 &, rai::stream &);
send_block (bool &, boost::property_tree::ptree const &); send_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash; using rai::block::hash;
@ -143,7 +143,7 @@ public:
class receive_block : public rai::block class receive_block : public rai::block
{ {
public: 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 &, rai::stream &);
receive_block (bool &, boost::property_tree::ptree const &); receive_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash; using rai::block::hash;
@ -182,7 +182,7 @@ public:
class open_block : public rai::block class open_block : public rai::block
{ {
public: 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 (rai::block_hash const &, rai::account const &, rai::account const &, std::nullptr_t);
open_block (bool &, rai::stream &); open_block (bool &, rai::stream &);
open_block (bool &, boost::property_tree::ptree const &); open_block (bool &, boost::property_tree::ptree const &);
@ -221,7 +221,7 @@ public:
class change_block : public rai::block class change_block : public rai::block
{ {
public: 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 &, rai::stream &);
change_block (bool &, boost::property_tree::ptree const &); change_block (bool &, boost::property_tree::ptree const &);
using rai::block::hash; using rai::block::hash;
@ -425,7 +425,7 @@ class vote
public: public:
vote () = default; vote () = default;
vote (bool &, rai::stream &, rai::block_type); 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; rai::uint256_union hash () const;
// Vote round sequence number // Vote round sequence number
uint64_t sequence; 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) // 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.data.bytes.data (), sizeof (key.data.bytes));
CryptoPP::AES::Encryption alg (key.bytes.data (), sizeof (key.bytes));
CryptoPP::CTR_Mode_ExternalCipher::Encryption enc (alg, iv.bytes.data ()); 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) 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 ()); 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 bool rai::uint256_union::is_zero () const
{ {
return qwords [0] == 0 && qwords [1] == 0 && qwords [2] == 0 && qwords [3] == 0; 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); 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 is an encoding using [0-9][a-z][A-Z] excluding characters that can be confused
// Base58check also has a 32bit error correction code. // Base58check also has a 32bit error correction code.
namespace 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; 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; return result;
} }

19
rai/utility.hpp
View file

@ -116,15 +116,15 @@ public:
}; };
// Balances are 128 bit. // Balances are 128 bit.
using amount = uint128_union; using amount = uint128_union;
class raw_key;
union uint256_union union uint256_union
{ {
uint256_union () = default; uint256_union () = default;
uint256_union (std::string const &); uint256_union (std::string const &);
uint256_union (uint64_t); uint256_union (uint64_t);
uint256_union (rai::uint256_t const &); 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 (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 &);
uint256_union operator ^ (rai::uint256_union const &) const; uint256_union operator ^ (rai::uint256_union const &) const;
bool 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 private_key = uint256_union;
using secret_key = uint256_union; using secret_key = uint256_union;
using checksum = 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 union uint512_union
{ {
uint512_union () = default; uint512_union () = default;
@ -172,6 +185,6 @@ union uint512_union
}; };
// Only signatures are 512 bit. // Only signatures are 512 bit.
using signature = uint512_union; 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 &); bool validate_message (rai::public_key const &, rai::uint256_union const &, rai::uint512_union const &);
} }