32 #include "gtest/gtest.h" 59 for (j = 0 ; j < N ; j++) {
63 if ( (
int)indi[j] == 0 ) {
76 indi[3] = (indi[3] + 1) % 2;
81 indi[3] = (indi[3] + 1) % 2;
105 for (j = 0 ; j < R ; j++) {
106 for (i = 0 ; i < N ; i++)
112 for (j = 0 ; j < R ; j++) {
128 for (j = 0 ; j < R ; j++) {
129 for (i = 0 ; i < N ; i++)
147 std::vector<uint64_t> inamounts;
149 inamounts.push_back(6000);
150 tie(sctmp, pctmp) =
ctskpkGen(inamounts.back());
155 inamounts.push_back(7000);
156 tie(sctmp, pctmp) =
ctskpkGen(inamounts.back());
159 vector<etn_amount >amounts;
164 amounts.push_back(500);
169 destinations.push_back(Pk);
173 amounts.push_back(12500);
176 destinations.push_back(Pk);
182 try {
genRct(
rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config,
hw::get_device(
"default")); }
183 catch(...) { ok =
true; }
187 rctSig s =
genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config,
hw::get_device(
"default"));
200 destinations[1] = Pk;
204 s =
genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config,
hw::get_device(
"default"));
213 TEST(ringct, range_proofs_with_fee)
219 std::vector<uint64_t> inamounts;
221 inamounts.push_back(6001);
222 tie(sctmp, pctmp) =
ctskpkGen(inamounts.back());
227 inamounts.push_back(7000);
228 tie(sctmp, pctmp) =
ctskpkGen(inamounts.back());
231 vector<etn_amount >amounts;
236 amounts.push_back(500);
241 destinations.push_back(Pk);
244 amounts.push_back(12500);
247 destinations.push_back(Pk);
252 rctSig s =
genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 1, 3, rct_config,
hw::get_device(
"default"));
265 destinations[1] = Pk;
269 s =
genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 500, 3, rct_config,
hw::get_device(
"default"));
283 vector<etn_amount>outamounts;
285 vector<etn_amount>inamounts;
297 inamounts.push_back(3000);
305 inamounts.push_back(3000);
308 outamounts.push_back(5000);
313 destinations.push_back(Pk);
316 outamounts.push_back(999);
320 destinations.push_back(Pk);
328 rctSig s =
genRctSimple(
message, sc, pc, destinations,inamounts, outamounts, amount_keys, NULL, NULL, txnfee, 2, rct_config,
hw::get_device(
"default"));
337 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)
341 vector<etn_amount >amounts;
346 for (
int n = 0; n < n_inputs; ++n) {
347 tie(sctmp, pctmp) =
ctskpkGen(input_amounts[n]);
352 for (
int n = 0; n < n_outputs; ++n) {
353 amounts.push_back(output_amounts[n]);
355 if (n < n_outputs - 1 || !last_is_fee)
357 destinations.push_back(Pk);
363 return genRct(
rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config,
hw::get_device(
"default"));
370 vector<etn_amount> inamounts, outamounts;
375 for (
int n = 0; n < n_inputs; ++n) {
376 inamounts.push_back(input_amounts[n]);
377 tie(sctmp, pctmp) =
ctskpkGen(input_amounts[n]);
382 for (
int n = 0; n < n_outputs; ++n) {
383 outamounts.push_back(output_amounts[n]);
386 destinations.push_back(Pk);
390 return genRctSimple(
rct::zero(), sc, pc, destinations, inamounts, outamounts, amount_keys, NULL, NULL, fee, 3, rct_config,
hw::get_device(
"default"));
393 static bool range_proof_test(
bool expected_valid,
394 int n_inputs,
const uint64_t input_amounts[],
int n_outputs,
const uint64_t output_amounts[],
bool last_is_fee,
bool simple)
402 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);
403 valid = verRctSimple(s);
406 s = make_sample_rct_sig(n_inputs, input_amounts, n_outputs, output_amounts, last_is_fee);
410 catch (
const std::exception &e) {
414 if (valid == expected_valid) {
422 #define NELTS(array) (sizeof(array)/sizeof(array[0])) 424 TEST(ringct, range_proofs_reject_empty_outs)
431 TEST(ringct, range_proofs_reject_empty_outs_simple)
438 TEST(ringct, range_proofs_reject_empty_ins)
445 TEST(ringct, range_proofs_reject_empty_ins_simple)
452 TEST(ringct, range_proofs_reject_all_empty)
459 TEST(ringct, range_proofs_reject_all_empty_simple)
466 TEST(ringct, range_proofs_accept_zero_empty)
473 TEST(ringct, range_proofs_accept_zero_empty_simple)
480 TEST(ringct, range_proofs_reject_empty_zero)
487 TEST(ringct, range_proofs_reject_empty_zero_simple)
494 TEST(ringct, range_proofs_accept_zero_zero)
501 TEST(ringct, range_proofs_accept_zero_zero_simple)
508 TEST(ringct, range_proofs_accept_zero_out_first)
511 const uint64_t outputs[] = {0, 5000};
515 TEST(ringct, range_proofs_accept_zero_out_first_simple)
518 const uint64_t outputs[] = {0, 5000};
522 TEST(ringct, range_proofs_accept_zero_out_last)
525 const uint64_t outputs[] = {5000, 0};
529 TEST(ringct, range_proofs_accept_zero_out_last_simple)
532 const uint64_t outputs[] = {5000, 0};
536 TEST(ringct, range_proofs_accept_zero_out_middle)
539 const uint64_t outputs[] = {2500, 0, 2500};
543 TEST(ringct, range_proofs_accept_zero_out_middle_simple)
546 const uint64_t outputs[] = {2500, 0, 2500};
550 TEST(ringct, range_proofs_accept_zero)
557 TEST(ringct, range_proofs_accept_zero_in_first_simple)
559 const uint64_t inputs[] = {0, 5000};
564 TEST(ringct, range_proofs_accept_zero_in_last_simple)
566 const uint64_t inputs[] = {5000, 0};
571 TEST(ringct, range_proofs_accept_zero_in_middle_simple)
573 const uint64_t inputs[] = {2500, 0, 2500};
578 TEST(ringct, range_proofs_reject_single_lower)
585 TEST(ringct, range_proofs_reject_single_lower_simple)
592 TEST(ringct, range_proofs_reject_single_higher)
599 TEST(ringct, range_proofs_reject_single_higher_simple)
606 TEST(ringct, range_proofs_reject_single_out_negative)
613 TEST(ringct, range_proofs_reject_single_out_negative_simple)
620 TEST(ringct, range_proofs_reject_out_negative_first)
627 TEST(ringct, range_proofs_reject_out_negative_first_simple)
634 TEST(ringct, range_proofs_reject_out_negative_last)
641 TEST(ringct, range_proofs_reject_out_negative_last_simple)
648 TEST(ringct, range_proofs_reject_out_negative_middle)
655 TEST(ringct, range_proofs_reject_out_negative_middle_simple)
662 TEST(ringct, range_proofs_reject_single_in_negative)
669 TEST(ringct, range_proofs_reject_single_in_negative_simple)
676 TEST(ringct, range_proofs_reject_in_negative_first)
683 TEST(ringct, range_proofs_reject_in_negative_first_simple)
690 TEST(ringct, range_proofs_reject_in_negative_last)
697 TEST(ringct, range_proofs_reject_in_negative_last_simple)
704 TEST(ringct, range_proofs_reject_in_negative_middle)
711 TEST(ringct, range_proofs_reject_in_negative_middle_simple)
718 TEST(ringct, range_proofs_reject_higher_list)
721 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
725 TEST(ringct, range_proofs_reject_higher_list_simple)
728 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
732 TEST(ringct, range_proofs_accept_1_to_1)
739 TEST(ringct, range_proofs_accept_1_to_1_simple)
746 TEST(ringct, range_proofs_accept_1_to_N)
749 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
753 TEST(ringct, range_proofs_accept_1_to_N_simple)
756 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
760 TEST(ringct, range_proofs_accept_N_to_1_simple)
762 const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
767 TEST(ringct, range_proofs_accept_N_to_N_simple)
769 const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
770 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
774 TEST(ringct, range_proofs_accept_very_long_simple)
779 for (
size_t n = 0; n < N; ++n) {
783 std::random_shuffle(inputs, inputs + N);
784 std::random_shuffle(outputs, outputs + N);
793 for (
int j = 0 ; j <
ATOMS ; j++) {
799 static const etn_amount test_amounts[]={0, 1, 2, 3, 4, 5, 10000, 10000000000000000000ull, 10203040506070809000ull, 123456789123456789};
805 for (
auto amount: test_amounts) {
813 for (
auto amount: test_amounts) {
820 TEST(ringct, prooveRange_is_non_deterministic)
823 for (
int n = 0; n < 2; ++n)
825 ASSERT_TRUE(memcmp(C[0].bytes, C[1].bytes,
sizeof(C[0].bytes)));
826 ASSERT_TRUE(memcmp(mask[0].bytes, mask[1].bytes,
sizeof(mask[0].bytes)));
832 const uint64_t outputs[] = {2000, 0};
836 TEST(ringct, fee_0_valid_simple)
838 const uint64_t inputs[] = {1000, 1000};
839 const uint64_t outputs[] = {2000, 0};
846 const uint64_t outputs[] = {1900, 100};
850 TEST(ringct, fee_non_0_valid_simple)
852 const uint64_t inputs[] = {1000, 1000};
853 const uint64_t outputs[] = {1900, 100};
857 TEST(ringct, fee_non_0_invalid_higher)
859 const uint64_t inputs[] = {1000, 1000};
860 const uint64_t outputs[] = {1990, 100};
864 TEST(ringct, fee_non_0_invalid_higher_simple)
866 const uint64_t inputs[] = {1000, 1000};
867 const uint64_t outputs[] = {1990, 100};
871 TEST(ringct, fee_non_0_invalid_lower)
873 const uint64_t inputs[] = {1000, 1000};
874 const uint64_t outputs[] = {1000, 100};
878 TEST(ringct, fee_non_0_invalid_lower_simple)
880 const uint64_t inputs[] = {1000, 1000};
881 const uint64_t outputs[] = {1000, 100};
885 TEST(ringct, fee_burn_valid_one_out)
888 const uint64_t outputs[] = {0, 2000};
892 TEST(ringct, fee_burn_valid_one_out_simple)
894 const uint64_t inputs[] = {1000, 1000};
895 const uint64_t outputs[] = {0, 2000};
899 TEST(ringct, fee_burn_valid_zero_out)
906 TEST(ringct, fee_burn_valid_zero_out_simple)
908 const uint64_t inputs[] = {1000, 1000};
915 static const uint64_t inputs[] = {2000};
916 static const uint64_t outputs[] = {1000, 1000};
921 #define TEST_rctSig_elements(name, op) \ 922 TEST(ringct, rctSig_##name) \ 924 rct::rctSig sig = make_sig(); \ 925 ASSERT_TRUE(rct::verRct(sig)); \ 927 ASSERT_FALSE(rct::verRct(sig)); \ 958 static const uint64_t inputs[] = {1000, 1000};
959 static const uint64_t outputs[] = {1000};
960 static rct::rctSig sig = make_sample_simple_rct_sig(
NELTS(inputs), inputs,
NELTS(outputs), outputs, 1000);
964 #define TEST_rctSig_elements_simple(name, op) \ 965 TEST(ringct, rctSig_##name##_simple) \ 967 rct::rctSig sig = make_sig_simple(); \ 968 ASSERT_TRUE(rct::verRctSimple(sig)); \ 970 ASSERT_FALSE(rct::verRctSimple(sig)); \ 1004 TEST(ringct, reject_gen_simple_ver_non_simple)
1006 const uint64_t inputs[] = {1000, 1000};
1012 TEST(ringct, reject_gen_non_simple_ver_simple)
1015 const uint64_t outputs[] = {1000, 1000};
1022 std::stringstream out;
1023 out <<
"BEGIN" << rct::H <<
"END";
1025 std::string{
"BEGIN<8b655970153799af2aeadc9ff1add0ea6c7251d54154cfa92c173a0dd39c1f94>END"},
1032 static const uint64_t amount = crypto::rand<uint64_t>();
1075 static const size_t N_PROOFS = 16;
1076 std::vector<rctSig> s(N_PROOFS);
1077 std::vector<const rctSig*> sp(N_PROOFS);
1079 for (
size_t n = 0; n < N_PROOFS; ++n)
1081 static const uint64_t inputs[] = {1000, 1000};
1082 static const uint64_t outputs[] = {500, 1500};
1083 s[n] = make_sample_simple_rct_sig(
NELTS(inputs), inputs,
NELTS(outputs), outputs, 0);
boroSig genBorromean(const key64 x, const key64 P1, const key64 P2, const bits indices)
rctSig genRctSimple(const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &inamounts, const vector< etn_amount > &outamounts, etn_amount txnFee, const ctkeyM &mixRing, const keyV &amount_keys, const std::vector< multisig_kLRki > *kLRki, multisig_out *msout, const std::vector< unsigned int > &index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
etn_amount h2d(const key &test)
#define EXPECT_TRUE(condition)
void addKeys1(key &aGB, const key &a, const key &B)
void d2h(key &amounth, const etn_amount in)
void scalarmultKey(key &aP, const key &P, const key &a)
std::vector< rangeSig > rangeSigs
GTEST_API_ AssertionResult AssertionFailure()
#define TEST_rctSig_elements(name, op)
bool verRct(const rctSig &rv, bool semantics)
bool verifyBorromean(const boroSig &bb, const ge_p3 P1[64], const ge_p3 P2[64])
tuple< ctkey, ctkey > ctskpkGen(etn_amount amount)
public_key addKeys(const public_key &A, const public_key &B)
void d2b(bits amountb, etn_amount val)
GTEST_API_ AssertionResult AssertionSuccess()
keyM keyMInit(size_t rows, size_t cols)
#define ASSERT_FALSE(condition)
std::vector< ecdhTuple > ecdhInfo
#define ASSERT_EQ(val1, val2)
#define TEST_rctSig_elements_simple(name, op)
device & get_device(const std::string &device_descriptor)
std::vector< ctkey > ctkeyV
unsigned __int64 uint64_t
bool MLSAG_Ver(const key &message, const keyM &pk, const mgSig &rv, size_t dsRows)
key scalarmultH(const key &a)
rctSig genRct(const key &message, const ctkeyV &inSk, const keyV &destinations, const vector< etn_amount > &amounts, const ctkeyM &mixRing, const keyV &amount_keys, const multisig_kLRki *kLRki, multisig_out *msout, unsigned int index, ctkeyV &outSk, const RCTConfig &rct_config, hw::device &hwdev)
void hash_to_scalar(key &hash, const void *data, const std::size_t l)
std::string message("Message requiring signing")
etn_amount randEtnAmount(etn_amount upperlimit)
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
void scalarmultBase(key &aG, const key &a)
rangeSig proveRange(key &C, key &mask, const etn_amount &amount)
void hash_to_scalar(const void *data, std::size_t length, crypto::ec_scalar &res)
#define ASSERT_TRUE(condition)
void subKeys(key &AB, const key &A, const key &B)
etn_amount b2d(bits amountb)
void skpkGen(key &sk, key &pk)
key scalarmult8(const key &P)
key zeroCommit(etn_amount amount)
int ge_frombytes_vartime(ge_p3 *, const unsigned char *)
void addKeys(key &AB, const key &A, const key &B)
bool equalKeys(const key &a, const key &b)
#define EXPECT_EQ(val1, val2)
etn_amount decodeRctSimple(const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
bool verRctSemanticsSimple(const std::vector< const rctSig *> &rvv)
key hashToPointSimple(const key &hh)
mgSig MLSAG_Gen(const key &message, const keyM &pk, const keyV &xx, const multisig_kLRki *kLRki, key *mscout, const unsigned int index, size_t dsRows, hw::device &hwdev)