aboutsummaryrefslogtreecommitdiff
path: root/tests/unit_tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unit_tests')
-rw-r--r--tests/unit_tests/CMakeLists.txt5
-rw-r--r--tests/unit_tests/hardfork.cpp2
-rw-r--r--tests/unit_tests/output_selection.cpp103
-rw-r--r--tests/unit_tests/ringct.cpp1070
-rw-r--r--tests/unit_tests/serialization.cpp198
5 files changed, 1376 insertions, 2 deletions
diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt
index 1b272cf5a..3d42809e3 100644
--- a/tests/unit_tests/CMakeLists.txt
+++ b/tests/unit_tests/CMakeLists.txt
@@ -51,7 +51,9 @@ set(unit_tests_sources
test_protocol_pack.cpp
hardfork.cpp
unbound.cpp
- varint.cpp)
+ varint.cpp
+ ringct.cpp
+ output_selection.cpp)
set(unit_tests_headers
unit_tests_utils.h)
@@ -61,6 +63,7 @@ add_executable(unit_tests
${unit_tests_headers})
target_link_libraries(unit_tests
LINK_PRIVATE
+ ringct
cryptonote_core
blockchain_db
rpc
diff --git a/tests/unit_tests/hardfork.cpp b/tests/unit_tests/hardfork.cpp
index eab6b9cf8..a279b6c68 100644
--- a/tests/unit_tests/hardfork.cpp
+++ b/tests/unit_tests/hardfork.cpp
@@ -96,7 +96,7 @@ public:
virtual void remove_block() { blocks.pop_back(); }
virtual uint64_t add_transaction_data(const crypto::hash& blk_hash, const transaction& tx, const crypto::hash& tx_hash) {return 0;}
virtual void remove_transaction_data(const crypto::hash& tx_hash, const transaction& tx) {}
- virtual uint64_t add_output(const crypto::hash& tx_hash, const tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time) {return 0;}
+ virtual uint64_t add_output(const crypto::hash& tx_hash, const tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time, const rct::key *commitment) {return 0;}
virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<uint64_t>& amount_output_indices) {}
virtual void add_spent_key(const crypto::key_image& k_image) {}
virtual void remove_spent_key(const crypto::key_image& k_image) {}
diff --git a/tests/unit_tests/output_selection.cpp b/tests/unit_tests/output_selection.cpp
new file mode 100644
index 000000000..4344d1ffc
--- /dev/null
+++ b/tests/unit_tests/output_selection.cpp
@@ -0,0 +1,103 @@
+// Copyright (c) 2014-2016, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// FIXME: move this into a full wallet2 unit test suite, if possible
+
+#include "gtest/gtest.h"
+
+#include "wallet/wallet2.h"
+#include <string>
+
+static tools::wallet2::transfer_container make_transfers_container(size_t N)
+{
+ tools::wallet2::transfer_container transfers;
+ for (size_t n = 0; n < N; ++n)
+ {
+ transfers.push_back(AUTO_VAL_INIT(tools::wallet2::transfer_details()));
+ tools::wallet2::transfer_details &td = transfers.back();
+ td.m_block_height = 1000;
+ td.m_spent = false;
+ td.m_txid = cryptonote::null_hash;
+ td.m_txid.data[0] = n & 0xff;
+ td.m_txid.data[1] = (n >> 8) & 0xff;
+ td.m_txid.data[2] = (n >> 16) & 0xff;
+ td.m_txid.data[3] = (n >> 24) & 0xff;
+ }
+ return transfers;
+}
+
+#define SELECT(idx) \
+ do { \
+ auto i = std::find(unused_indices.begin(), unused_indices.end(), idx); \
+ ASSERT_TRUE(i != unused_indices.end()); \
+ unused_indices.erase(i); \
+ selected.push_back(transfers.begin() + idx); \
+ } while(0)
+
+#define PICK(expected) \
+ do { \
+ size_t idx = w.pop_best_value_from(transfers, unused_indices, selected); \
+ ASSERT_EQ(expected, idx); \
+ selected.push_back(transfers.begin() + idx); \
+ } while(0)
+
+TEST(select_outputs, one_out_of_N)
+{
+ tools::wallet2 w;
+
+ // check that if there are N-1 outputs of the same height, one of them
+ // already selected, the next one selected is the one that's from a
+ // different height
+ tools::wallet2::transfer_container transfers = make_transfers_container(10);
+ transfers[6].m_block_height = 700;
+ std::vector<size_t> unused_indices({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+ std::list<tools::wallet2::transfer_container::iterator> selected;
+ SELECT(2);
+ PICK(6);
+}
+
+TEST(select_outputs, order)
+{
+ tools::wallet2 w;
+
+ // check that most unrelated heights are picked in order
+ tools::wallet2::transfer_container transfers = make_transfers_container(5);
+ transfers[0].m_block_height = 700;
+ transfers[1].m_block_height = 700;
+ transfers[2].m_block_height = 704;
+ transfers[3].m_block_height = 716;
+ transfers[4].m_block_height = 701;
+ std::vector<size_t> unused_indices({0, 1, 2, 3, 4});
+ std::list<tools::wallet2::transfer_container::iterator> selected;
+ SELECT(0);
+ PICK(3); // first the one that's far away
+ PICK(2); // then the one that's close
+ PICK(4); // then the one that's adjacent
+ PICK(1); // then the one that's on the same height
+}
+
diff --git a/tests/unit_tests/ringct.cpp b/tests/unit_tests/ringct.cpp
new file mode 100644
index 000000000..224e32e61
--- /dev/null
+++ b/tests/unit_tests/ringct.cpp
@@ -0,0 +1,1070 @@
+// Copyright (c) 2014-2016, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+// of conditions and the following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#include "gtest/gtest.h"
+
+#include <cstdint>
+#include <algorithm>
+
+#include "ringct/rctTypes.h"
+#include "ringct/rctSigs.h"
+#include "ringct/rctOps.h"
+
+using namespace crypto;
+using namespace rct;
+
+TEST(ringct, SNL)
+{
+ key x, P1;
+ skpkGen(x, P1);
+
+ key P2 = pkGen();
+ key P3 = pkGen();
+
+ key L1, s1, s2;
+ GenSchnorrNonLinkable(L1, s1, s2, x, P1, P2, 0);
+
+ // a valid one
+ // an invalid one
+ ASSERT_TRUE(VerSchnorrNonLinkable(P1, P2, L1, s1, s2));
+ ASSERT_FALSE(VerSchnorrNonLinkable(P1, P3, L1, s1, s2));
+}
+
+TEST(ringct, ASNL)
+{
+ int j = 0;
+
+ //Tests for ASNL
+ //#ASNL true one, false one, C != sum Ci, and one out of the range..
+ int N = 64;
+ key64 xv;
+ key64 P1v;
+ key64 P2v;
+ bits indi;
+
+ for (j = 0 ; j < N ; j++) {
+ indi[j] = (int)randXmrAmount(2);
+
+ xv[j] = skGen();
+ if ( (int)indi[j] == 0 ) {
+ P1v[j] = scalarmultBase(xv[j]);
+ P2v[j] = pkGen();
+
+ } else {
+
+ P2v[j] = scalarmultBase(xv[j]);
+ P1v[j] = pkGen();
+
+ }
+ }
+
+ //#true one
+ asnlSig L1s2s = GenASNL(xv, P1v, P2v, indi);
+ ASSERT_TRUE(VerASNL(P1v, P2v, L1s2s));
+
+ //#false one
+ indi[3] = (indi[3] + 1) % 2;
+ L1s2s = GenASNL(xv, P1v, P2v, indi);
+ ASSERT_FALSE(VerASNL(P1v, P2v, L1s2s));
+
+ //#true one again
+ indi[3] = (indi[3] + 1) % 2;
+ L1s2s = GenASNL(xv, P1v, P2v, indi);
+ ASSERT_TRUE(VerASNL(P1v, P2v, L1s2s));
+
+ //#false one
+ L1s2s = GenASNL(xv, P2v, P1v, indi);
+ ASSERT_FALSE(VerASNL(P1v, P2v, L1s2s));
+}
+
+TEST(ringct, MG_sigs)
+{
+ int j = 0;
+ int N = 0;
+
+ //Tests for MG Sigs
+ //#MG sig: true one
+ N = 3;// #cols
+ int R = 3;// #rows
+ keyV xtmp = skvGen(R);
+ keyM xm = keyMInit(R, N);// = [[None]*N] #just used to generate test public keys
+ keyV sk = skvGen(R);
+ keyM P = keyMInit(R, N);// = keyM[[None]*N] #stores the public keys;
+ int ind = 2;
+ int i = 0;
+ for (j = 0 ; j < R ; j++) {
+ for (i = 0 ; i < N ; i++)
+ {
+ xm[i][j] = skGen();
+ P[i][j] = scalarmultBase(xm[i][j]);
+ }
+ }
+ for (j = 0 ; j < R ; j++) {
+ sk[j] = xm[ind][j];
+ }
+ key message = identity();
+ mgSig IIccss = MLSAG_Gen(message, P, sk, ind, R);
+ ASSERT_TRUE(MLSAG_Ver(message, P, IIccss, R));
+
+ //#MG sig: false one
+ N = 3;// #cols
+ R = 3;// #rows
+ xtmp = skvGen(R);
+ keyM xx(N, xtmp);// = [[None]*N] #just used to generate test public keys
+ sk = skvGen(R);
+ //P (N, xtmp);// = keyM[[None]*N] #stores the public keys;
+
+ ind = 2;
+ for (j = 0 ; j < R ; j++) {
+ for (i = 0 ; i < N ; i++)
+ {
+ xx[i][j] = skGen();
+ P[i][j] = scalarmultBase(xx[i][j]);
+ }
+ sk[j] = xx[ind][j];
+ }
+ sk[2] = skGen();//asume we don't know one of the private keys..
+ IIccss = MLSAG_Gen(message, P, sk, ind, R);
+ ASSERT_FALSE(MLSAG_Ver(message, P, IIccss, R));
+}
+
+TEST(ringct, range_proofs)
+{
+ //Ring CT Stuff
+ //ct range proofs
+ ctkeyV sc, pc;
+ ctkey sctmp, pctmp;
+ //add fake input 5000
+ tie(sctmp, pctmp) = ctskpkGen(6000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+
+
+ tie(sctmp, pctmp) = ctskpkGen(7000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ vector<xmr_amount >amounts;
+ rct::keyV amount_keys;
+ key mask;
+
+ //add output 500
+ amounts.push_back(500);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ keyV destinations;
+ key Sk, Pk;
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+
+ //add output for 12500
+ amounts.push_back(12500);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+ //compute rct data with mixin 500
+ rctSig s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+ //verify rct data
+ ASSERT_TRUE(verRct(s));
+
+ //decode received amount
+ ASSERT_TRUE(decodeRct(s, amount_keys[1], 1, mask));
+
+ // Ring CT with failing MG sig part should not verify!
+ // Since sum of inputs != outputs
+
+ amounts[1] = 12501;
+ skpkGen(Sk, Pk);
+ destinations[1] = Pk;
+
+
+ //compute rct data with mixin 500
+ s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+ //verify rct data
+ ASSERT_FALSE(verRct(s));
+
+ //decode received amount
+ ASSERT_TRUE(decodeRct(s, amount_keys[1], 1, mask));
+}
+
+TEST(ringct, range_proofs_with_fee)
+{
+ //Ring CT Stuff
+ //ct range proofs
+ ctkeyV sc, pc;
+ ctkey sctmp, pctmp;
+ //add fake input 5000
+ tie(sctmp, pctmp) = ctskpkGen(6001);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+
+
+ tie(sctmp, pctmp) = ctskpkGen(7000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ vector<xmr_amount >amounts;
+ keyV amount_keys;
+ key mask;
+
+ //add output 500
+ amounts.push_back(500);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ keyV destinations;
+ key Sk, Pk;
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+ //add txn fee for 1
+ //has no corresponding destination..
+ amounts.push_back(1);
+ amount_keys.push_back(hash_to_scalar(zero()));
+
+ //add output for 12500
+ amounts.push_back(12500);
+ amount_keys.push_back(hash_to_scalar(zero()));
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+ //compute rct data with mixin 500
+ rctSig s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+ //verify rct data
+ ASSERT_TRUE(verRct(s));
+
+ //decode received amount
+ ASSERT_TRUE(decodeRct(s, amount_keys[1], 1, mask));
+
+ // Ring CT with failing MG sig part should not verify!
+ // Since sum of inputs != outputs
+
+ amounts[1] = 12501;
+ skpkGen(Sk, Pk);
+ destinations[1] = Pk;
+
+
+ //compute rct data with mixin 500
+ s = genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+ //verify rct data
+ ASSERT_FALSE(verRct(s));
+
+ //decode received amount
+ ASSERT_TRUE(decodeRct(s, amount_keys[1], 1, mask));
+}
+
+TEST(ringct, simple)
+{
+ ctkeyV sc, pc;
+ ctkey sctmp, pctmp;
+ //this vector corresponds to output amounts
+ vector<xmr_amount>outamounts;
+ //this vector corresponds to input amounts
+ vector<xmr_amount>inamounts;
+ //this keyV corresponds to destination pubkeys
+ keyV destinations;
+ keyV amount_keys;
+ key mask;
+
+ //add fake input 3000
+ //the sc is secret data
+ //pc is public data
+ tie(sctmp, pctmp) = ctskpkGen(3000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ inamounts.push_back(3000);
+
+ //add fake input 3000
+ //the sc is secret data
+ //pc is public data
+ tie(sctmp, pctmp) = ctskpkGen(3000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ inamounts.push_back(3000);
+
+ //add output 5000
+ outamounts.push_back(5000);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ //add the corresponding destination pubkey
+ key Sk, Pk;
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+ //add output 999
+ outamounts.push_back(999);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ //add the corresponding destination pubkey
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+
+ key message = skGen(); //real message later (hash of txn..)
+
+ //compute sig with mixin 2
+ xmr_amount txnfee = 1;
+
+ rctSig s = genRctSimple(message, sc, pc, destinations,inamounts, outamounts, amount_keys, txnfee, 2);
+
+ //verify ring ct signature
+ ASSERT_TRUE(verRctSimple(s));
+
+ //decode received amount corresponding to output pubkey index 1
+ ASSERT_TRUE(decodeRctSimple(s, amount_keys[1], 1, mask));
+}
+
+static rct::rctSig make_sample_rct_sig(int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee)
+{
+ ctkeyV sc, pc;
+ ctkey sctmp, pctmp;
+ vector<xmr_amount >amounts;
+ keyV destinations;
+ keyV amount_keys;
+ key Sk, Pk;
+
+ for (int n = 0; n < n_inputs; ++n) {
+ tie(sctmp, pctmp) = ctskpkGen(input_amounts[n]);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ }
+
+ for (int n = 0; n < n_outputs; ++n) {
+ amounts.push_back(output_amounts[n]);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ skpkGen(Sk, Pk);
+ if (n < n_outputs - 1 || !last_is_fee)
+ destinations.push_back(Pk);
+ }
+
+ return genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);;
+}
+
+static rct::rctSig make_sample_simple_rct_sig(int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], uint64_t fee)
+{
+ ctkeyV sc, pc;
+ ctkey sctmp, pctmp;
+ vector<xmr_amount> inamounts, outamounts;
+ keyV destinations;
+ keyV amount_keys;
+ key Sk, Pk;
+
+ for (int n = 0; n < n_inputs; ++n) {
+ inamounts.push_back(input_amounts[n]);
+ tie(sctmp, pctmp) = ctskpkGen(input_amounts[n]);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ }
+
+ for (int n = 0; n < n_outputs; ++n) {
+ outamounts.push_back(output_amounts[n]);
+ amount_keys.push_back(hash_to_scalar(zero()));
+ skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ }
+
+ return genRctSimple(rct::zero(), sc, pc, destinations, inamounts, outamounts, amount_keys, fee, 3);;
+}
+
+static bool range_proof_test(bool expected_valid,
+ int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee, bool simple)
+{
+ //compute rct data
+ bool valid;
+ try {
+ rctSig s;
+ // simple takes fee as a parameter, non-simple takes it as an extra element to output amounts
+ if (simple) {
+ s = make_sample_simple_rct_sig(n_inputs, input_amounts, last_is_fee ? n_outputs - 1 : n_outputs, output_amounts, last_is_fee ? output_amounts[n_outputs - 1] : 0);
+ valid = verRctSimple(s);
+ }
+ else {
+ s = make_sample_rct_sig(n_inputs, input_amounts, n_outputs, output_amounts, last_is_fee);
+ valid = verRct(s);
+ }
+ }
+ catch (const std::exception &e) {
+ valid = false;
+ }
+
+ if (valid == expected_valid) {
+ return testing::AssertionSuccess();
+ }
+ else {
+ return testing::AssertionFailure();
+ }
+}
+
+#define NELTS(array) (sizeof(array)/sizeof(array[0]))
+
+TEST(ringct, range_proofs_reject_empty_outs)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_empty_outs_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_empty_ins)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_empty_ins_simple)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_all_empty)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_all_empty_simple)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_empty)
+{
+ const uint64_t inputs[] = {0};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_empty_simple)
+{
+ const uint64_t inputs[] = {0};
+ const uint64_t outputs[] = {};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_empty_zero)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {0};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_empty_zero_simple)
+{
+ const uint64_t inputs[] = {};
+ const uint64_t outputs[] = {0};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_zero)
+{
+ const uint64_t inputs[] = {0};
+ const uint64_t outputs[] = {0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_zero_simple)
+{
+ const uint64_t inputs[] = {0};
+ const uint64_t outputs[] = {0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_first)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {0, 5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_first_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {0, 5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_last)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5000, 0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_last_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5000, 0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_middle)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {2500, 0, 2500};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_out_middle_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {2500, 0, 2500};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_first)
+{
+ const uint64_t inputs[] = {0, 5000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_first_simple)
+{
+ const uint64_t inputs[] = {0, 5000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_last)
+{
+ const uint64_t inputs[] = {5000, 0};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_last_simple)
+{
+ const uint64_t inputs[] = {5000, 0};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_middle)
+{
+ const uint64_t inputs[] = {2500, 0, 2500};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_zero_in_middle_simple)
+{
+ const uint64_t inputs[] = {2500, 0, 2500};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_single_lower)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_single_lower_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_single_higher)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5001};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_single_higher_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5001};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_single_out_negative)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {(uint64_t)-1000ll};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_single_out_negative_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {(uint64_t)-1000ll};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_first)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {(uint64_t)-1000ll, 6000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_first_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {(uint64_t)-1000ll, 6000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_last)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {6000, (uint64_t)-1000ll};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_last_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {6000, (uint64_t)-1000ll};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_middle)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_out_negative_middle_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_single_in_negative)
+{
+ const uint64_t inputs[] = {(uint64_t)-1000ll};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_single_in_negative_simple)
+{
+ const uint64_t inputs[] = {(uint64_t)-1000ll};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_first)
+{
+ const uint64_t inputs[] = {(uint64_t)-1000ll, 6000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_first_simple)
+{
+ const uint64_t inputs[] = {(uint64_t)-1000ll, 6000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_last)
+{
+ const uint64_t inputs[] = {6000, (uint64_t)-1000ll};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_last_simple)
+{
+ const uint64_t inputs[] = {6000, (uint64_t)-1000ll};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_middle)
+{
+ const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_in_negative_middle_simple)
+{
+ const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_reject_higher_list)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_reject_higher_list_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_1_to_1)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_1_to_1_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_1_to_N)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_1_to_N_simple)
+{
+ const uint64_t inputs[] = {5000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false,true));
+}
+
+TEST(ringct, range_proofs_accept_N_to_1)
+{
+ const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_N_to_1_simple)
+{
+ const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
+ const uint64_t outputs[] = {5000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_N_to_N)
+{
+ const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_N_to_N_simple)
+{
+ const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
+ const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, range_proofs_accept_very_long)
+{
+ const size_t N=12;
+ uint64_t inputs[N];
+ uint64_t outputs[N];
+ for (size_t n = 0; n < N; ++n) {
+ inputs[n] = n;
+ outputs[n] = n;
+ }
+ std::random_shuffle(inputs, inputs + N);
+ std::random_shuffle(outputs, outputs + N);
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
+}
+
+TEST(ringct, range_proofs_accept_very_long_simple)
+{
+ const size_t N=12;
+ uint64_t inputs[N];
+ uint64_t outputs[N];
+ for (size_t n = 0; n < N; ++n) {
+ inputs[n] = n;
+ outputs[n] = n;
+ }
+ std::random_shuffle(inputs, inputs + N);
+ std::random_shuffle(outputs, outputs + N);
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
+}
+
+TEST(ringct, HPow2)
+{
+ key G = scalarmultBase(d2h(1));
+
+ key H = hashToPointSimple(G);
+ for (int j = 0 ; j < ATOMS ; j++) {
+ ASSERT_TRUE(equalKeys(H, H2[j]));
+ addKeys(H, H, H);
+ }
+}
+
+static const xmr_amount test_amounts[]={0, 1, 2, 3, 4, 5, 10000, 10000000000000000000ull, 10203040506070809000ull, 123456789123456789};
+
+TEST(ringct, ecdh_roundtrip)
+{
+ key k;
+ ecdhTuple t0, t1;
+
+ for (auto amount: test_amounts) {
+ skGen(k);
+
+ t0.mask = skGen();
+ t0.amount = d2h(amount);
+
+ t1 = t0;
+ ecdhEncode(t1, k);
+ ecdhDecode(t1, k);
+ ASSERT_TRUE(t0.mask == t1.mask);
+ ASSERT_TRUE(equalKeys(t0.mask, t1.mask));
+ ASSERT_TRUE(t0.amount == t1.amount);
+ ASSERT_TRUE(equalKeys(t0.amount, t1.amount));
+ }
+}
+
+TEST(ringct, d2h)
+{
+ key k, P1;
+ skpkGen(k, P1);
+ for (auto amount: test_amounts) {
+ d2h(k, amount);
+ ASSERT_TRUE(amount == h2d(k));
+ }
+}
+
+TEST(ringct, d2b)
+{
+ for (auto amount: test_amounts) {
+ bits b;
+ d2b(b, amount);
+ ASSERT_TRUE(amount == b2d(b));
+ }
+}
+
+TEST(ringct, prooveRange_is_non_deterministic)
+{
+ key C[2], mask[2];
+ for (int n = 0; n < 2; ++n)
+ proveRange(C[n], mask[n], 80);
+ ASSERT_TRUE(memcmp(C[0].bytes, C[1].bytes, sizeof(C[0].bytes)));
+ ASSERT_TRUE(memcmp(mask[0].bytes, mask[1].bytes, sizeof(mask[0].bytes)));
+}
+
+TEST(ringct, fee_0_valid)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {2000, 0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_0_valid_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {2000, 0};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+TEST(ringct, fee_non_0_valid)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1900, 100};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_non_0_valid_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1900, 100};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+TEST(ringct, fee_non_0_invalid_higher)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1990, 100};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_non_0_invalid_higher_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1990, 100};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+TEST(ringct, fee_non_0_invalid_lower)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1000, 100};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_non_0_invalid_lower_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1000, 100};
+ EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+TEST(ringct, fee_burn_valid_one_out)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {0, 2000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_burn_valid_one_out_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {0, 2000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+TEST(ringct, fee_burn_valid_zero_out)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {2000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
+}
+
+TEST(ringct, fee_burn_valid_zero_out_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {2000};
+ EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
+}
+
+#define TEST_rctSig_elements(name, op) \
+TEST(ringct, rctSig_##name) \
+{ \
+ const uint64_t inputs[] = {1000, 1000}; \
+ const uint64_t outputs[] = {1000, 1000}; \
+ rct::rctSig sig = make_sample_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, true); \
+ ASSERT_TRUE(rct::verRct(sig)); \
+ op; \
+ ASSERT_FALSE(rct::verRct(sig)); \
+}
+
+TEST_rctSig_elements(rangeSigs_empty, sig.p.rangeSigs.resize(0));
+TEST_rctSig_elements(rangeSigs_too_many, sig.p.rangeSigs.push_back(sig.p.rangeSigs.back()));
+TEST_rctSig_elements(rangeSigs_too_few, sig.p.rangeSigs.pop_back());
+TEST_rctSig_elements(mgSig_MG_empty, sig.p.MGs.resize(0));
+TEST_rctSig_elements(mgSig_ss_empty, sig.p.MGs[0].ss.resize(0));
+TEST_rctSig_elements(mgSig_ss_too_many, sig.p.MGs[0].ss.push_back(sig.p.MGs[0].ss.back()));
+TEST_rctSig_elements(mgSig_ss_too_few, sig.p.MGs[0].ss.pop_back());
+TEST_rctSig_elements(mgSig_ss0_empty, sig.p.MGs[0].ss[0].resize(0));
+TEST_rctSig_elements(mgSig_ss0_too_many, sig.p.MGs[0].ss[0].push_back(sig.p.MGs[0].ss[0].back()));
+TEST_rctSig_elements(mgSig_ss0_too_few, sig.p.MGs[0].ss[0].pop_back());
+TEST_rctSig_elements(mgSig_II_empty, sig.p.MGs[0].II.resize(0));
+TEST_rctSig_elements(mgSig_II_too_many, sig.p.MGs[0].II.push_back(sig.p.MGs[0].II.back()));
+TEST_rctSig_elements(mgSig_II_too_few, sig.p.MGs[0].II.pop_back());
+TEST_rctSig_elements(mixRing_empty, sig.mixRing.resize(0));
+TEST_rctSig_elements(mixRing_too_many, sig.mixRing.push_back(sig.mixRing.back()));
+TEST_rctSig_elements(mixRing_too_few, sig.mixRing.pop_back());
+TEST_rctSig_elements(mixRing0_empty, sig.mixRing[0].resize(0));
+TEST_rctSig_elements(mixRing0_too_many, sig.mixRing[0].push_back(sig.mixRing[0].back()));
+TEST_rctSig_elements(mixRing0_too_few, sig.mixRing[0].pop_back());
+TEST_rctSig_elements(ecdhInfo_empty, sig.ecdhInfo.resize(0));
+TEST_rctSig_elements(ecdhInfo_too_many, sig.ecdhInfo.push_back(sig.ecdhInfo.back()));
+TEST_rctSig_elements(ecdhInfo_too_few, sig.ecdhInfo.pop_back());
+TEST_rctSig_elements(outPk_empty, sig.outPk.resize(0));
+TEST_rctSig_elements(outPk_too_many, sig.outPk.push_back(sig.outPk.back()));
+TEST_rctSig_elements(outPk_too_few, sig.outPk.pop_back());
+
+#define TEST_rctSig_elements_simple(name, op) \
+TEST(ringct, rctSig_##name##_simple) \
+{ \
+ const uint64_t inputs[] = {1000, 1000}; \
+ const uint64_t outputs[] = {1000}; \
+ rct::rctSig sig = make_sample_simple_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, 1000); \
+ ASSERT_TRUE(rct::verRctSimple(sig)); \
+ op; \
+ ASSERT_FALSE(rct::verRctSimple(sig)); \
+}
+
+TEST_rctSig_elements_simple(rangeSigs_empty, sig.p.rangeSigs.resize(0));
+TEST_rctSig_elements_simple(rangeSigs_too_many, sig.p.rangeSigs.push_back(sig.p.rangeSigs.back()));
+TEST_rctSig_elements_simple(rangeSigs_too_few, sig.p.rangeSigs.pop_back());
+TEST_rctSig_elements_simple(mgSig_empty, sig.p.MGs.resize(0));
+TEST_rctSig_elements_simple(mgSig_too_many, sig.p.MGs.push_back(sig.p.MGs.back()));
+TEST_rctSig_elements_simple(mgSig_too_few, sig.p.MGs.pop_back());
+TEST_rctSig_elements_simple(mgSig0_ss_empty, sig.p.MGs[0].ss.resize(0));
+TEST_rctSig_elements_simple(mgSig0_ss_too_many, sig.p.MGs[0].ss.push_back(sig.p.MGs[0].ss.back()));
+TEST_rctSig_elements_simple(mgSig0_ss_too_few, sig.p.MGs[0].ss.pop_back());
+TEST_rctSig_elements_simple(mgSig_ss0_empty, sig.p.MGs[0].ss[0].resize(0));
+TEST_rctSig_elements_simple(mgSig_ss0_too_many, sig.p.MGs[0].ss[0].push_back(sig.p.MGs[0].ss[0].back()));
+TEST_rctSig_elements_simple(mgSig_ss0_too_few, sig.p.MGs[0].ss[0].pop_back());
+TEST_rctSig_elements_simple(mgSig0_II_empty, sig.p.MGs[0].II.resize(0));
+TEST_rctSig_elements_simple(mgSig0_II_too_many, sig.p.MGs[0].II.push_back(sig.p.MGs[0].II.back()));
+TEST_rctSig_elements_simple(mgSig0_II_too_few, sig.p.MGs[0].II.pop_back());
+TEST_rctSig_elements_simple(mixRing_empty, sig.mixRing.resize(0));
+TEST_rctSig_elements_simple(mixRing_too_many, sig.mixRing.push_back(sig.mixRing.back()));
+TEST_rctSig_elements_simple(mixRing_too_few, sig.mixRing.pop_back());
+TEST_rctSig_elements_simple(mixRing0_empty, sig.mixRing[0].resize(0));
+TEST_rctSig_elements_simple(mixRing0_too_many, sig.mixRing[0].push_back(sig.mixRing[0].back()));
+TEST_rctSig_elements_simple(mixRing0_too_few, sig.mixRing[0].pop_back());
+TEST_rctSig_elements_simple(pseudoOuts_empty, sig.pseudoOuts.resize(0));
+TEST_rctSig_elements_simple(pseudoOuts_too_many, sig.pseudoOuts.push_back(sig.pseudoOuts.back()));
+TEST_rctSig_elements_simple(pseudoOuts_too_few, sig.pseudoOuts.pop_back());
+TEST_rctSig_elements_simple(ecdhInfo_empty, sig.ecdhInfo.resize(0));
+TEST_rctSig_elements_simple(ecdhInfo_too_many, sig.ecdhInfo.push_back(sig.ecdhInfo.back()));
+TEST_rctSig_elements_simple(ecdhInfo_too_few, sig.ecdhInfo.pop_back());
+TEST_rctSig_elements_simple(outPk_empty, sig.outPk.resize(0));
+TEST_rctSig_elements_simple(outPk_too_many, sig.outPk.push_back(sig.outPk.back()));
+TEST_rctSig_elements_simple(outPk_too_few, sig.outPk.pop_back());
+
+TEST(ringct, reject_gen_simple_ver_non_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1000};
+ rct::rctSig sig = make_sample_simple_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, 1000);
+ ASSERT_FALSE(rct::verRct(sig));
+}
+
+TEST(ringct, reject_gen_non_simple_ver_simple)
+{
+ const uint64_t inputs[] = {1000, 1000};
+ const uint64_t outputs[] = {1000, 1000};
+ rct::rctSig sig = make_sample_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, true);
+ ASSERT_FALSE(rct::verRctSimple(sig));
+}
diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp
index b110a41ab..40209f6ed 100644
--- a/tests/unit_tests/serialization.cpp
+++ b/tests/unit_tests/serialization.cpp
@@ -36,6 +36,7 @@
#include <boost/foreach.hpp>
#include "cryptonote_core/cryptonote_basic.h"
#include "cryptonote_core/cryptonote_basic_impl.h"
+#include "ringct/rctSigs.h"
#include "serialization/serialization.h"
#include "serialization/binary_archive.h"
#include "serialization/json_archive.h"
@@ -442,3 +443,200 @@ TEST(Serialization, serializes_transacion_signatures_correctly)
blob.resize(blob.size() + sizeof(crypto::signature) / 2);
ASSERT_FALSE(serialization::parse_binary(blob, tx1));
}
+
+TEST(Serialization, serializes_ringct_types)
+{
+ string blob;
+ rct::key key0, key1;
+ rct::keyV keyv0, keyv1;
+ rct::keyM keym0, keym1;
+ rct::ctkey ctkey0, ctkey1;
+ rct::ctkeyV ctkeyv0, ctkeyv1;
+ rct::ctkeyM ctkeym0, ctkeym1;
+ rct::ecdhTuple ecdh0, ecdh1;
+ rct::asnlSig asnl0, asnl1;
+ rct::mgSig mg0, mg1;
+ rct::rangeSig rg0, rg1;
+ rct::rctSig s0, s1;
+ cryptonote::transaction tx0, tx1;
+
+ key0 = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(key0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, key1));
+ ASSERT_TRUE(key0 == key1);
+
+ keyv0 = rct::skvGen(30);
+ for (size_t n = 0; n < keyv0.size(); ++n)
+ keyv0[n] = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(keyv0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, keyv1));
+ ASSERT_TRUE(keyv0.size() == keyv1.size());
+ for (size_t n = 0; n < keyv0.size(); ++n)
+ {
+ ASSERT_TRUE(keyv0[n] == keyv1[n]);
+ }
+
+ keym0 = rct::keyMInit(9, 12);
+ for (size_t n = 0; n < keym0.size(); ++n)
+ for (size_t i = 0; i < keym0[n].size(); ++i)
+ keym0[n][i] = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(keym0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, keym1));
+ ASSERT_TRUE(keym0.size() == keym1.size());
+ for (size_t n = 0; n < keym0.size(); ++n)
+ {
+ ASSERT_TRUE(keym0[n].size() == keym1[n].size());
+ for (size_t i = 0; i < keym0[n].size(); ++i)
+ {
+ ASSERT_TRUE(keym0[n][i] == keym1[n][i]);
+ }
+ }
+
+ rct::skpkGen(ctkey0.dest, ctkey0.mask);
+ ASSERT_TRUE(serialization::dump_binary(ctkey0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkey1));
+ ASSERT_TRUE(!memcmp(&ctkey0, &ctkey1, sizeof(ctkey0)));
+
+ ctkeyv0 = std::vector<rct::ctkey>(14);
+ for (size_t n = 0; n < ctkeyv0.size(); ++n)
+ rct::skpkGen(ctkeyv0[n].dest, ctkeyv0[n].mask);
+ ASSERT_TRUE(serialization::dump_binary(ctkeyv0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkeyv1));
+ ASSERT_TRUE(ctkeyv0.size() == ctkeyv1.size());
+ for (size_t n = 0; n < ctkeyv0.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&ctkeyv0[n], &ctkeyv1[n], sizeof(ctkeyv0[n])));
+ }
+
+ ctkeym0 = std::vector<rct::ctkeyV>(9);
+ for (size_t n = 0; n < ctkeym0.size(); ++n)
+ {
+ ctkeym0[n] = std::vector<rct::ctkey>(11);
+ for (size_t i = 0; i < ctkeym0[n].size(); ++i)
+ rct::skpkGen(ctkeym0[n][i].dest, ctkeym0[n][i].mask);
+ }
+ ASSERT_TRUE(serialization::dump_binary(ctkeym0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ctkeym1));
+ ASSERT_TRUE(ctkeym0.size() == ctkeym1.size());
+ for (size_t n = 0; n < ctkeym0.size(); ++n)
+ {
+ ASSERT_TRUE(ctkeym0[n].size() == ctkeym1[n].size());
+ for (size_t i = 0; i < ctkeym0.size(); ++i)
+ {
+ ASSERT_TRUE(!memcmp(&ctkeym0[n][i], &ctkeym1[n][i], sizeof(ctkeym0[n][i])));
+ }
+ }
+
+ ecdh0.mask = rct::skGen();
+ ecdh0.amount = rct::skGen();
+ ecdh0.senderPk = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(ecdh0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, ecdh1));
+ ASSERT_TRUE(!memcmp(&ecdh0.mask, &ecdh1.mask, sizeof(ecdh0.mask)));
+ ASSERT_TRUE(!memcmp(&ecdh0.amount, &ecdh1.amount, sizeof(ecdh0.amount)));
+ // senderPk is not serialized
+
+ for (size_t n = 0; n < 64; ++n)
+ {
+ asnl0.L1[n] = rct::skGen();
+ asnl0.s2[n] = rct::skGen();
+ }
+ asnl0.s = rct::skGen();
+ ASSERT_TRUE(serialization::dump_binary(asnl0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, asnl1));
+ ASSERT_TRUE(!memcmp(&asnl0, &asnl1, sizeof(asnl0)));
+
+ // create a full rct signature to use its innards
+ rct::ctkeyV sc, pc;
+ rct::ctkey sctmp, pctmp;
+ tie(sctmp, pctmp) = rct::ctskpkGen(6000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ tie(sctmp, pctmp) = rct::ctskpkGen(7000);
+ sc.push_back(sctmp);
+ pc.push_back(pctmp);
+ vector<uint64_t> amounts;
+ rct::keyV amount_keys;
+ //add output 500
+ amounts.push_back(500);
+ rct::keyV destinations;
+ rct::key Sk, Pk;
+ rct::skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ //add output for 12500
+ amounts.push_back(12500);
+ amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
+ rct::skpkGen(Sk, Pk);
+ destinations.push_back(Pk);
+ //compute rct data with mixin 500
+ s0 = rct::genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, 3);
+
+ mg0 = s0.p.MGs[0];
+ ASSERT_TRUE(serialization::dump_binary(mg0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, mg1));
+ ASSERT_TRUE(mg0.ss.size() == mg1.ss.size());
+ for (size_t n = 0; n < mg0.ss.size(); ++n)
+ {
+ ASSERT_TRUE(mg0.ss[n] == mg1.ss[n]);
+ }
+ ASSERT_TRUE(mg0.cc == mg1.cc);
+
+ // mixRing and II are not serialized, they are meant to be reconstructed
+ ASSERT_TRUE(mg1.II.empty());
+
+ rg0 = s0.p.rangeSigs.front();
+ ASSERT_TRUE(serialization::dump_binary(rg0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, rg1));
+ ASSERT_TRUE(!memcmp(&rg0, &rg1, sizeof(rg0)));
+
+ ASSERT_TRUE(serialization::dump_binary(s0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, s1));
+ ASSERT_TRUE(s0.type == s1.type);
+ ASSERT_TRUE(s0.p.rangeSigs.size() == s1.p.rangeSigs.size());
+ for (size_t n = 0; n < s0.p.rangeSigs.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&s0.p.rangeSigs[n], &s1.p.rangeSigs[n], sizeof(s0.p.rangeSigs[n])));
+ }
+ ASSERT_TRUE(s0.p.MGs.size() == s1.p.MGs.size());
+ ASSERT_TRUE(s0.p.MGs[0].ss.size() == s1.p.MGs[0].ss.size());
+ for (size_t n = 0; n < s0.p.MGs[0].ss.size(); ++n)
+ {
+ ASSERT_TRUE(s0.p.MGs[0].ss[n] == s1.p.MGs[0].ss[n]);
+ }
+ ASSERT_TRUE(s0.p.MGs[0].cc == s1.p.MGs[0].cc);
+ // mixRing and II are not serialized, they are meant to be reconstructed
+ ASSERT_TRUE(s1.p.MGs[0].II.empty());
+
+ // mixRing and II are not serialized, they are meant to be reconstructed
+ ASSERT_TRUE(s1.mixRing.size() == 0);
+
+ ASSERT_TRUE(s0.ecdhInfo.size() == s1.ecdhInfo.size());
+ for (size_t n = 0; n < s0.ecdhInfo.size(); ++n)
+ {
+ ASSERT_TRUE(!memcmp(&s0.ecdhInfo[n], &s1.ecdhInfo[n], sizeof(s0.ecdhInfo[n])));
+ }
+ ASSERT_TRUE(s0.outPk.size() == s1.outPk.size());
+ for (size_t n = 0; n < s0.outPk.size(); ++n)
+ {
+ // serialization only does the mask
+ ASSERT_TRUE(!memcmp(&s0.outPk[n].mask, &s1.outPk[n].mask, sizeof(s0.outPk[n].mask)));
+ }
+
+ tx0.set_null();
+ tx0.version = 2;
+ cryptonote::txin_to_key txin_to_key1;
+ txin_to_key1.key_offsets.resize(2);
+ cryptonote::txin_to_key txin_to_key2;
+ txin_to_key2.key_offsets.resize(2);
+ tx0.vin.push_back(txin_to_key1);
+ tx0.vin.push_back(txin_to_key2);
+ tx0.vout.push_back(cryptonote::tx_out());
+ tx0.rct_signatures = s0;
+ ASSERT_EQ(tx0.rct_signatures.p.rangeSigs.size(), 2);
+ ASSERT_TRUE(serialization::dump_binary(tx0, blob));
+ ASSERT_TRUE(serialization::parse_binary(blob, tx1));
+ ASSERT_EQ(tx1.rct_signatures.p.rangeSigs.size(), 2);
+ std::string blob2;
+ ASSERT_TRUE(serialization::dump_binary(tx1, blob2));
+ ASSERT_TRUE(blob == blob2);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-10 21:15:16 +0000