Batch state blocks signatures verification

rai/core_test/node.cpp

@@ -1815,3 +1815,81 @@ TEST (node, fork_invalid_block_signature_vote_by_hash)
 	}
 	ASSERT_EQ (system.nodes[0]->block (send2.hash ())->block_signature (), send2.block_signature ());
 }
+
+TEST (node, block_processor_signatures)
+{
+	rai::system system0 (24000, 1);
+	auto & node1 (*system0.nodes[0]);
+	system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
+	rai::block_hash latest (system0.nodes[0]->latest (rai::test_genesis_key.pub));
+	rai::keypair key1;
+	auto send1 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, latest, rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node1.work_generate_blocking (*send1);
+	rai::keypair key2;
+	auto send2 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, send1->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Gxrb_ratio, key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node1.work_generate_blocking (*send2);
+	rai::keypair key3;
+	auto send3 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, send2->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 3 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node1.work_generate_blocking (*send3);
+	// Invalid signature bit
+	auto send4 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 4 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node1.work_generate_blocking (*send4);
+	send4->signature.bytes[32] ^= 0x1;
+	// Invalid signature bit (force)
+	auto send5 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 5 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node1.work_generate_blocking (*send5);
+	send5->signature.bytes[31] ^= 0x1;
+	// Invalid signature to unchecked
+	{
+		auto transaction (node1.store.tx_begin_write ());
+		node1.store.unchecked_put (transaction, send5->previous (), send5);
+	}
+	auto receive1 (std::make_shared<rai::state_block> (key1.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, 0));
+	node1.work_generate_blocking (*receive1);
+	auto receive2 (std::make_shared<rai::state_block> (key2.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, 0));
+	node1.work_generate_blocking (*receive2);
+	// Invalid private key
+	auto receive3 (std::make_shared<rai::state_block> (key3.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send3->hash (), key2.prv, key3.pub, 0));
+	node1.work_generate_blocking (*receive3);
+	node1.process_active (send1);
+	node1.process_active (send2);
+	node1.process_active (send3);
+	node1.process_active (send4);
+	node1.process_active (receive1);
+	node1.process_active (receive2);
+	node1.process_active (receive3);
+	node1.block_processor.flush ();
+	node1.block_processor.force (send5);
+	node1.block_processor.flush ();
+	auto transaction (node1.store.tx_begin_read ());
+	ASSERT_TRUE (node1.store.block_exists (transaction, send1->hash ()));
+	ASSERT_TRUE (node1.store.block_exists (transaction, send2->hash ()));
+	ASSERT_TRUE (node1.store.block_exists (transaction, send3->hash ()));
+	ASSERT_FALSE (node1.store.block_exists (transaction, send4->hash ()));
+	ASSERT_FALSE (node1.store.block_exists (transaction, send5->hash ()));
+	ASSERT_TRUE (node1.store.block_exists (transaction, receive1->hash ()));
+	ASSERT_TRUE (node1.store.block_exists (transaction, receive2->hash ()));
+	ASSERT_FALSE (node1.store.block_exists (transaction, receive3->hash ()));
+}
+
+/*
+ *  State blocks go through a different signature path, ensure invalidly signed state blocks are rejected
+ */
+TEST (node, block_processor_reject_state)
+{
+	rai::system system (24000, 1);
+	auto & node (*system.nodes[0]);
+	rai::genesis genesis;
+	auto send1 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node.work_generate_blocking (*send1);
+	send1->signature.bytes[0] ^= 1;
+	ASSERT_FALSE (node.ledger.block_exists (send1->hash ()));
+	node.process_active (send1);
+	node.block_processor.flush ();
+	ASSERT_FALSE (node.ledger.block_exists (send1->hash ()));
+	auto send2 (std::make_shared<rai::state_block> (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Gxrb_ratio, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
+	node.work_generate_blocking (*send2);
+	node.process_active (send2);
+	node.block_processor.flush ();
+	ASSERT_TRUE (node.ledger.block_exists (send2->hash ()));
+}

rai/lib/blocks.cpp

@@ -321,6 +321,11 @@ rai::block_hash rai::send_block::root () const
 	return hashables.previous;
 }
 
+rai::block_hash rai::send_block::link () const
+{
+	return 0;
+}
+
 rai::account rai::send_block::representative () const
 {
 	return 0;
@@ -575,6 +580,11 @@ rai::block_hash rai::open_block::root () const
 	return hashables.account;
 }
 
+rai::block_hash rai::open_block::link () const
+{
+	return 0;
+}
+
 rai::account rai::open_block::representative () const
 {
 	return hashables.representative;
@@ -811,6 +821,11 @@ rai::block_hash rai::change_block::root () const
 	return hashables.previous;
 }
 
+rai::block_hash rai::change_block::link () const
+{
+	return 0;
+}
+
 rai::account rai::change_block::representative () const
 {
 	return hashables.representative;
@@ -1110,6 +1125,11 @@ rai::block_hash rai::state_block::root () const
 	return !hashables.previous.is_zero () ? hashables.previous : hashables.account;
 }
 
+rai::block_hash rai::state_block::link () const
+{
+	return hashables.link;
+}
+
 rai::account rai::state_block::representative () const
 {
 	return hashables.representative;
@@ -1440,6 +1460,11 @@ rai::block_hash rai::receive_block::root () const
 	return hashables.previous;
 }
 
+rai::block_hash rai::receive_block::link () const
+{
+	return 0;
+}
+
 rai::account rai::receive_block::representative () const
 {
 	return 0;

rai/lib/blocks.hpp

@@ -54,6 +54,8 @@ class block
 	virtual rai::block_hash source () const = 0;
 	// Previous block or account number for open blocks
 	virtual rai::block_hash root () const = 0;
+	// Link field for state blocks, zero otherwise.
+	virtual rai::block_hash link () const = 0;
 	virtual rai::account representative () const = 0;
 	virtual void serialize (rai::stream &) const = 0;
 	virtual void serialize_json (std::string &) const = 0;
@@ -90,6 +92,7 @@ class send_block : public rai::block
 	rai::block_hash previous () const override;
 	rai::block_hash source () const override;
 	rai::block_hash root () const override;
+	rai::block_hash link () const override;
 	rai::account representative () const override;
 	void serialize (rai::stream &) const override;
 	void serialize_json (std::string &) const override;
@@ -131,6 +134,7 @@ class receive_block : public rai::block
 	rai::block_hash previous () const override;
 	rai::block_hash source () const override;
 	rai::block_hash root () const override;
+	rai::block_hash link () const override;
 	rai::account representative () const override;
 	void serialize (rai::stream &) const override;
 	void serialize_json (std::string &) const override;
@@ -174,6 +178,7 @@ class open_block : public rai::block
 	rai::block_hash previous () const override;
 	rai::block_hash source () const override;
 	rai::block_hash root () const override;
+	rai::block_hash link () const override;
 	rai::account representative () const override;
 	void serialize (rai::stream &) const override;
 	void serialize_json (std::string &) const override;
@@ -215,6 +220,7 @@ class change_block : public rai::block
 	rai::block_hash previous () const override;
 	rai::block_hash source () const override;
 	rai::block_hash root () const override;
+	rai::block_hash link () const override;
 	rai::account representative () const override;
 	void serialize (rai::stream &) const override;
 	void serialize_json (std::string &) const override;
@@ -268,6 +274,7 @@ class state_block : public rai::block
 	rai::block_hash previous () const override;
 	rai::block_hash source () const override;
 	rai::block_hash root () const override;
+	rai::block_hash link () const override;
 	rai::account representative () const override;
 	void serialize (rai::stream &) const override;
 	void serialize_json (std::string &) const override;

rai/lib/numbers.cpp

@@ -434,6 +434,12 @@ bool rai::validate_message (rai::public_key const & public_key, rai::uint256_uni
 	return result;
 }
 
+bool rai::validate_message_batch (const unsigned char ** m, size_t * mlen, const unsigned char ** pk, const unsigned char ** RS, size_t num, int * valid)
+{
+	bool result (0 == ed25519_sign_open_batch (m, mlen, pk, RS, num, valid));
+	return result;
+}
+
 rai::uint128_union::uint128_union (std::string const & string_a)
 {
 	auto error (decode_hex (string_a));

rai/lib/numbers.hpp

@@ -127,6 +127,7 @@ using signature = uint512_union;
 
 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_batch (const unsigned char **, size_t *, const unsigned char **, const unsigned char **, size_t, int *);
 void deterministic_key (rai::uint256_union const &, uint32_t, rai::uint256_union &);
 rai::public_key pub_key (rai::private_key const &);
 }

rai/node/node.cpp

@@ -936,7 +936,7 @@ void rai::block_processor::stop ()
 void rai::block_processor::flush ()
 {
 	std::unique_lock<std::mutex> lock (mutex);
-	while (!stopped && (!blocks.empty () || active))
+	while (!stopped && (have_blocks () || active))
 	{
 		condition.wait (lock);
 	}
@@ -955,8 +955,14 @@ void rai::block_processor::add (std::shared_ptr<rai::block> block_a, std::chrono
 		std::lock_guard<std::mutex> lock (mutex);
 		if (blocks_hashes.find (block_a->hash ()) == blocks_hashes.end ())
 		{
-			blocks.push_back (std::make_pair (block_a, origination));
-			blocks_hashes.insert (block_a->hash ());
+			if (block_a->type () == rai::block_type::state && block_a->link () != node.ledger.epoch_link)
+			{
+				state_blocks.push_back (std::make_pair (block_a, origination));
+			}
+			else
+			{
+				blocks.push_back (std::make_pair (block_a, origination));
+			}
 			condition.notify_all ();
 		}
 	}
@@ -1010,16 +1016,63 @@ bool rai::block_processor::should_log ()
 bool rai::block_processor::have_blocks ()
 {
 	assert (!mutex.try_lock ());
-	return !blocks.empty () || !forced.empty ();
+	return !blocks.empty () || !forced.empty () || !state_blocks.empty ();
+}
+
+void rai::block_processor::verify_state_blocks (std::unique_lock<std::mutex> & lock_a)
+{
+	lock_a.lock ();
+	std::deque<std::pair<std::shared_ptr<rai::block>, std::chrono::steady_clock::time_point>> items;
+	items.swap (state_blocks);
+	lock_a.unlock ();
+	auto size (items.size ());
+	std::vector<rai::uint256_union> hashes;
+	hashes.reserve (size);
+	std::vector<unsigned char const *> messages;
+	messages.reserve (size);
+	std::vector<size_t> lengths;
+	lengths.reserve (size);
+	std::vector<unsigned char const *> pub_keys;
+	pub_keys.reserve (size);
+	std::vector<unsigned char const *> signatures;
+	signatures.reserve (size);
+	std::vector<int> verifications;
+	verifications.resize (size);
+	for (auto i (0); i < size; ++i)
+	{
+		auto & block (static_cast<rai::state_block &> (*items[i].first));
+		hashes.push_back (block.hash ());
+		messages.push_back (hashes.back ().bytes.data ());
+		lengths.push_back (sizeof (decltype (hashes)::value_type));
+		pub_keys.push_back (block.hashables.account.bytes.data ());
+		signatures.push_back (block.signature.bytes.data ());
+	}
+	/* Verifications is vector if signatures check results
+	validate_message_batch returing "true" if there are at least 1 invalid signature */
+	auto code (rai::validate_message_batch (messages.data (), lengths.data (), pub_keys.data (), signatures.data (), size, verifications.data ()));
+	(void)code;
+	lock_a.lock ();
+	for (auto i (0); i < size; ++i)
+	{
+		assert (verifications[i] == 1 || verifications[i] == 0);
+		if (verifications[i] == 1)
+		{
+			blocks.push_back (items.front ());
+		}
+		items.pop_front ();
+	}
+	lock_a.unlock ();
 }
 
 void rai::block_processor::process_receive_many (std::unique_lock<std::mutex> & lock_a)
 {
+	verify_state_blocks (lock_a);
 	{
 		auto transaction (node.store.tx_begin_write ());
 		auto start_time (std::chrono::steady_clock::now ());
 		lock_a.lock ();
-		while (have_blocks () && std::chrono::steady_clock::now () - start_time < node.config.block_processor_batch_max_time)
+		// Processing blocks
+		while ((!blocks.empty () || !forced.empty ()) && std::chrono::steady_clock::now () - start_time < node.config.block_processor_batch_max_time)
 		{
 			if (blocks.size () > 64 && should_log ())
 			{
@@ -1051,7 +1104,10 @@ void rai::block_processor::process_receive_many (std::unique_lock<std::mutex> &
 					node.ledger.rollback (transaction, successor->hash ());
 				}
 			}
-			auto process_result (process_receive_one (transaction, block.first, block.second));
+			/* Forced state blocks are not validated in verify_state_blocks () function
+			Because of that we should set set validated_state_block as "false" for forced state blocks (!force) */
+			bool validated_state_block (!force && block.first->type () == rai::block_type::state);
+			auto process_result (process_receive_one (transaction, block.first, block.second, validated_state_block));
 			(void)process_result;
 			lock_a.lock ();
 		}
@@ -1073,11 +1129,11 @@ void rai::block_processor::process_receive_many (std::unique_lock<std::mutex> &
 	}
 }
 
-rai::process_return rai::block_processor::process_receive_one (rai::transaction const & transaction_a, std::shared_ptr<rai::block> block_a, std::chrono::steady_clock::time_point origination)
+rai::process_return rai::block_processor::process_receive_one (rai::transaction const & transaction_a, std::shared_ptr<rai::block> block_a, std::chrono::steady_clock::time_point origination, bool validated_state_block)
 {
 	rai::process_return result;
 	auto hash (block_a->hash ());
-	result = node.ledger.process (transaction_a, *block_a);
+	result = node.ledger.process (transaction_a, *block_a, validated_state_block);
 	switch (result.code)
 	{
 		case rai::process_result::progress:

rai/node/node.hpp

@@ -503,15 +503,17 @@ class block_processor
 	bool should_log ();
 	bool have_blocks ();
 	void process_blocks ();
-	rai::process_return process_receive_one (rai::transaction const &, std::shared_ptr<rai::block>, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now ());
+	rai::process_return process_receive_one (rai::transaction const &, std::shared_ptr<rai::block>, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now (), bool = false);
 
 private:
 	void queue_unchecked (rai::transaction const &, rai::block_hash const &);
 	void process_receive_many (std::unique_lock<std::mutex> &);
+	void verify_state_blocks (std::unique_lock<std::mutex> &);
 	bool stopped;
 	bool active;
 	std::chrono::steady_clock::time_point next_log;
 	std::deque<std::pair<std::shared_ptr<rai::block>, std::chrono::steady_clock::time_point>> blocks;
+	std::deque<std::pair<std::shared_ptr<rai::block>, std::chrono::steady_clock::time_point>> state_blocks;
 	std::unordered_set<rai::block_hash> blocks_hashes;
 	std::deque<std::shared_ptr<rai::block>> forced;
 	std::deque<std::shared_ptr<rai::block>> processed_active;

rai/rai_node/entry.cpp

@@ -31,6 +31,7 @@ int main (int argc, char * const * argv)
 		("debug_profile_verify", "Profile work verification")
 		("debug_profile_kdf", "Profile kdf function")
 		("debug_verify_profile", "Profile signature verification")
+		("debug_verify_profile_batch", "Profile batch signature verification")
 		("debug_profile_sign", "Profile signature generation")
 		("debug_profile_process", "Profile active blocks processing (only for rai_test_network)")
 		("debug_validate_blocks", "Check all blocks for correct hash, signature, work value")
@@ -311,6 +312,23 @@ int main (int argc, char * const * argv)
 			auto end (std::chrono::high_resolution_clock::now ());
 			std::cerr << "Signature verifications " << std::chrono::duration_cast<std::chrono::microseconds> (end - begin).count () << std::endl;
 		}
+		else if (vm.count ("debug_verify_profile_batch"))
+		{
+			rai::keypair key;
+			size_t batch_count (1000);
+			rai::uint256_union message;
+			rai::uint512_union signature (rai::sign_message (key.prv, key.pub, message));
+			std::vector<unsigned char const *> messages (batch_count, message.bytes.data ());
+			std::vector<size_t> lengths (batch_count, sizeof (message));
+			std::vector<unsigned char const *> pub_keys (batch_count, key.pub.bytes.data ());
+			std::vector<unsigned char const *> signatures (batch_count, signature.bytes.data ());
+			std::vector<int> verifications;
+			verifications.resize (batch_count);
+			auto begin (std::chrono::high_resolution_clock::now ());
+			rai::validate_message_batch (messages.data (), lengths.data (), pub_keys.data (), signatures.data (), batch_count, verifications.data ());
+			auto end (std::chrono::high_resolution_clock::now ());
+			std::cerr << "Batch signature verifications " << std::chrono::duration_cast<std::chrono::microseconds> (end - begin).count () << std::endl;
+		}
 		else if (vm.count ("debug_profile_sign"))
 		{
 			std::cerr << "Starting blocks signing profiling\n";