Electroneum
Loading...
Searching...
No Matches
ringct.cpp File Reference
#include "gtest/gtest.h"
#include <cstdint>
#include <algorithm>
#include <sstream>
#include "ringct/rctTypes.h"
#include "ringct/rctSigs.h"
#include "ringct/rctOps.h"
#include "device/device.hpp"
Include dependency graph for ringct.cpp:

Go to the source code of this file.

Macros

#define NELTS(array)
#define TEST_rctSig_elements(name, op)
#define TEST_rctSig_elements_simple(name, op)

Functions

 TEST (ringct, Borromean)
 TEST (ringct, MG_sigs)
 TEST (ringct, range_proofs)
 TEST (ringct, range_proofs_with_fee)
 TEST (ringct, simple)
 TEST (ringct, range_proofs_reject_empty_outs)
 TEST (ringct, range_proofs_reject_empty_outs_simple)
 TEST (ringct, range_proofs_reject_empty_ins)
 TEST (ringct, range_proofs_reject_empty_ins_simple)
 TEST (ringct, range_proofs_reject_all_empty)
 TEST (ringct, range_proofs_reject_all_empty_simple)
 TEST (ringct, range_proofs_accept_zero_empty)
 TEST (ringct, range_proofs_accept_zero_empty_simple)
 TEST (ringct, range_proofs_reject_empty_zero)
 TEST (ringct, range_proofs_reject_empty_zero_simple)
 TEST (ringct, range_proofs_accept_zero_zero)
 TEST (ringct, range_proofs_accept_zero_zero_simple)
 TEST (ringct, range_proofs_accept_zero_out_first)
 TEST (ringct, range_proofs_accept_zero_out_first_simple)
 TEST (ringct, range_proofs_accept_zero_out_last)
 TEST (ringct, range_proofs_accept_zero_out_last_simple)
 TEST (ringct, range_proofs_accept_zero_out_middle)
 TEST (ringct, range_proofs_accept_zero_out_middle_simple)
 TEST (ringct, range_proofs_accept_zero)
 TEST (ringct, range_proofs_accept_zero_in_first_simple)
 TEST (ringct, range_proofs_accept_zero_in_last_simple)
 TEST (ringct, range_proofs_accept_zero_in_middle_simple)
 TEST (ringct, range_proofs_reject_single_lower)
 TEST (ringct, range_proofs_reject_single_lower_simple)
 TEST (ringct, range_proofs_reject_single_higher)
 TEST (ringct, range_proofs_reject_single_higher_simple)
 TEST (ringct, range_proofs_reject_single_out_negative)
 TEST (ringct, range_proofs_reject_single_out_negative_simple)
 TEST (ringct, range_proofs_reject_out_negative_first)
 TEST (ringct, range_proofs_reject_out_negative_first_simple)
 TEST (ringct, range_proofs_reject_out_negative_last)
 TEST (ringct, range_proofs_reject_out_negative_last_simple)
 TEST (ringct, range_proofs_reject_out_negative_middle)
 TEST (ringct, range_proofs_reject_out_negative_middle_simple)
 TEST (ringct, range_proofs_reject_single_in_negative)
 TEST (ringct, range_proofs_reject_single_in_negative_simple)
 TEST (ringct, range_proofs_reject_in_negative_first)
 TEST (ringct, range_proofs_reject_in_negative_first_simple)
 TEST (ringct, range_proofs_reject_in_negative_last)
 TEST (ringct, range_proofs_reject_in_negative_last_simple)
 TEST (ringct, range_proofs_reject_in_negative_middle)
 TEST (ringct, range_proofs_reject_in_negative_middle_simple)
 TEST (ringct, range_proofs_reject_higher_list)
 TEST (ringct, range_proofs_reject_higher_list_simple)
 TEST (ringct, range_proofs_accept_1_to_1)
 TEST (ringct, range_proofs_accept_1_to_1_simple)
 TEST (ringct, range_proofs_accept_1_to_N)
 TEST (ringct, range_proofs_accept_1_to_N_simple)
 TEST (ringct, range_proofs_accept_N_to_1_simple)
 TEST (ringct, range_proofs_accept_N_to_N_simple)
 TEST (ringct, range_proofs_accept_very_long_simple)
 TEST (ringct, HPow2)
 TEST (ringct, d2h)
 TEST (ringct, d2b)
 TEST (ringct, prooveRange_is_non_deterministic)
 TEST (ringct, fee_0_valid)
 TEST (ringct, fee_0_valid_simple)
 TEST (ringct, fee_non_0_valid)
 TEST (ringct, fee_non_0_valid_simple)
 TEST (ringct, fee_non_0_invalid_higher)
 TEST (ringct, fee_non_0_invalid_higher_simple)
 TEST (ringct, fee_non_0_invalid_lower)
 TEST (ringct, fee_non_0_invalid_lower_simple)
 TEST (ringct, fee_burn_valid_one_out)
 TEST (ringct, fee_burn_valid_one_out_simple)
 TEST (ringct, fee_burn_valid_zero_out)
 TEST (ringct, fee_burn_valid_zero_out_simple)
 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())
 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)
 TEST (ringct, reject_gen_non_simple_ver_simple)
 TEST (ringct, key_ostream)
 TEST (ringct, zeroCommmit)
 TEST (ringct, zeroCommitCache)
 TEST (ringct, H)
 TEST (ringct, mul8)
 TEST (ringct, aggregated)

Macro Definition Documentation

◆ NELTS

#define NELTS ( array)
Value:
(sizeof(array)/sizeof(array[0]))

Definition at line 422 of file ringct.cpp.

◆ TEST_rctSig_elements

#define TEST_rctSig_elements ( name,
op )
Value:
TEST(ringct, rctSig_##name) \
{ \
rct::rctSig sig = make_sig(); \
ASSERT_TRUE(rct::verRct(sig)); \
op; \
ASSERT_FALSE(rct::verRct(sig)); \
}
TEST
#define TEST(test_case_name, test_name)
Definition gtest.h:2187
rct::verRct
bool verRct(const rctSig &rv, bool semantics)
Definition rctSigs.cpp:913

Definition at line 921 of file ringct.cpp.

921#define TEST_rctSig_elements(name, op) \
922TEST(ringct, rctSig_##name) \
923{ \
924 rct::rctSig sig = make_sig(); \
925 ASSERT_TRUE(rct::verRct(sig)); \
926 op; \
927 ASSERT_FALSE(rct::verRct(sig)); \
928}

◆ TEST_rctSig_elements_simple

#define TEST_rctSig_elements_simple ( name,
op )
Value:
TEST(ringct, rctSig_##name##_simple) \
{ \
rct::rctSig sig = make_sig_simple(); \
ASSERT_TRUE(rct::verRctSimple(sig)); \
op; \
ASSERT_FALSE(rct::verRctSimple(sig)); \
}

Definition at line 964 of file ringct.cpp.

964#define TEST_rctSig_elements_simple(name, op) \
965TEST(ringct, rctSig_##name##_simple) \
966{ \
967 rct::rctSig sig = make_sig_simple(); \
968 ASSERT_TRUE(rct::verRctSimple(sig)); \
969 op; \
970 ASSERT_FALSE(rct::verRctSimple(sig)); \
971}

Function Documentation

◆ TEST() [1/80]

TEST ( ringct ,
aggregated  )

Definition at line 1073 of file ringct.cpp.

1074{
1075 static const size_t N_PROOFS = 16;
1076 std::vector<rctSig> s(N_PROOFS);
1077 std::vector<const rctSig*> sp(N_PROOFS);
1078
1079 for (size_t n = 0; n < N_PROOFS; ++n)
1080 {
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);
1084 sp[n] = &s[n];
1085 }
1086
1087 ASSERT_TRUE(verRctSemanticsSimple(sp));
1088}
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition gtest.h:1865
rct::verRctSemanticsSimple
bool verRctSemanticsSimple(const std::vector< const rctSig * > &rvv)
Definition rctSigs.cpp:975
NELTS
#define NELTS(array)
Definition ringct.cpp:422
uint64_t
unsigned __int64 uint64_t
Definition stdint.h:136
Here is the call graph for this function:

◆ TEST() [2/80]

TEST ( ringct ,
Borromean  )

Definition at line 47 of file ringct.cpp.

48{
49 int j = 0;
50
51 //Tests for Borromean signatures
52 //#boro true one, false one, C != sum Ci, and one out of the range..
53 int N = 64;
54 key64 xv;
55 key64 P1v;
56 key64 P2v;
57 bits indi;
58
59 for (j = 0 ; j < N ; j++) {
60 indi[j] = (int)randEtnAmount(2);
61
62 xv[j] = skGen();
63 if ( (int)indi[j] == 0 ) {
64 scalarmultBase(P1v[j], xv[j]);
65 } else {
66 addKeys1(P1v[j], xv[j], H2[j]);
67 }
68 subKeys(P2v[j], P1v[j], H2[j]);
69 }
70
71 //#true one
72 boroSig bb = genBorromean(xv, P1v, P2v, indi);
73 ASSERT_TRUE(verifyBorromean(bb, P1v, P2v));
74
75 //#false one
76 indi[3] = (indi[3] + 1) % 2;
77 bb = genBorromean(xv, P1v, P2v, indi);
78 ASSERT_FALSE(verifyBorromean(bb, P1v, P2v));
79
80 //#true one again
81 indi[3] = (indi[3] + 1) % 2;
82 bb = genBorromean(xv, P1v, P2v, indi);
83 ASSERT_TRUE(verifyBorromean(bb, P1v, P2v));
84
85 //#false one
86 bb = genBorromean(xv, P2v, P1v, indi);
87 ASSERT_FALSE(verifyBorromean(bb, P1v, P2v));
88}
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Definition gtest.h:1868
rct::scalarmultBase
void scalarmultBase(key &aG, const key &a)
Definition rctOps.cpp:350
rct::skGen
key skGen()
Definition rctOps.cpp:258
rct::subKeys
void subKeys(key &AB, const key &A, const key &B)
Definition rctOps.cpp:505
rct::genBorromean
boroSig genBorromean(const key64 x, const key64 P1, const key64 P2, const bits indices)
Definition rctSigs.cpp:109
rct::key64
key key64[64]
Definition rctTypes.h:137
rct::bits
unsigned int bits[ATOMS]
Definition rctTypes.h:136
rct::addKeys1
void addKeys1(key &aGB, const key &a, const key &B)
Definition rctOps.cpp:459
rct::verifyBorromean
bool verifyBorromean(const boroSig &bb, const ge_p3 P1[64], const ge_p3 P2[64])
Definition rctSigs.cpp:140
rct::randEtnAmount
etn_amount randEtnAmount(etn_amount upperlimit)
Definition rctOps.cpp:343
Here is the call graph for this function:

◆ TEST() [3/80]

TEST ( ringct ,
d2b  )

Definition at line 811 of file ringct.cpp.

812{
813 for (auto amount: test_amounts) {
814 bits b;
815 d2b(b, amount);
816 ASSERT_TRUE(amount == b2d(b));
817 }
818}
rct::b2d
etn_amount b2d(bits amountb)
Definition rctTypes.cpp:205
rct::d2b
void d2b(bits amountb, etn_amount val)
Definition rctTypes.cpp:145
Here is the call graph for this function:

◆ TEST() [4/80]

TEST ( ringct ,
d2h  )

Definition at line 801 of file ringct.cpp.

802{
803 key k, P1;
804 skpkGen(k, P1);
805 for (auto amount: test_amounts) {
806 d2h(k, amount);
807 ASSERT_TRUE(amount == h2d(k));
808 }
809}
rct::skpkGen
tuple< key, key > skpkGen()
Definition rctOps.cpp:290
rct::h2d
etn_amount h2d(const key &test)
Definition rctTypes.cpp:161
rct::d2h
void d2h(key &amounth, const etn_amount in)
Definition rctTypes.cpp:119
Here is the call graph for this function:

◆ TEST() [5/80]

TEST ( ringct ,
fee_0_valid  )

Definition at line 829 of file ringct.cpp.

830{
831 const uint64_t inputs[] = {2000};
832 const uint64_t outputs[] = {2000, 0};
833 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
834}
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition gtest.h:1859

◆ TEST() [6/80]

TEST ( ringct ,
fee_0_valid_simple  )

Definition at line 836 of file ringct.cpp.

837{
838 const uint64_t inputs[] = {1000, 1000};
839 const uint64_t outputs[] = {2000, 0};
840 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
841}

◆ TEST() [7/80]

TEST ( ringct ,
fee_burn_valid_one_out  )

Definition at line 885 of file ringct.cpp.

886{
887 const uint64_t inputs[] = {2000};
888 const uint64_t outputs[] = {0, 2000};
889 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
890}

◆ TEST() [8/80]

TEST ( ringct ,
fee_burn_valid_one_out_simple  )

Definition at line 892 of file ringct.cpp.

893{
894 const uint64_t inputs[] = {1000, 1000};
895 const uint64_t outputs[] = {0, 2000};
896 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
897}

◆ TEST() [9/80]

TEST ( ringct ,
fee_burn_valid_zero_out  )

Definition at line 899 of file ringct.cpp.

900{
901 const uint64_t inputs[] = {2000};
902 const uint64_t outputs[] = {2000};
903 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
904}

◆ TEST() [10/80]

TEST ( ringct ,
fee_burn_valid_zero_out_simple  )

Definition at line 906 of file ringct.cpp.

907{
908 const uint64_t inputs[] = {1000, 1000};
909 const uint64_t outputs[] = {2000};
910 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
911}

◆ TEST() [11/80]

TEST ( ringct ,
fee_non_0_invalid_higher  )

Definition at line 857 of file ringct.cpp.

858{
859 const uint64_t inputs[] = {1000, 1000};
860 const uint64_t outputs[] = {1990, 100};
861 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
862}

◆ TEST() [12/80]

TEST ( ringct ,
fee_non_0_invalid_higher_simple  )

Definition at line 864 of file ringct.cpp.

865{
866 const uint64_t inputs[] = {1000, 1000};
867 const uint64_t outputs[] = {1990, 100};
868 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
869}

◆ TEST() [13/80]

TEST ( ringct ,
fee_non_0_invalid_lower  )

Definition at line 871 of file ringct.cpp.

872{
873 const uint64_t inputs[] = {1000, 1000};
874 const uint64_t outputs[] = {1000, 100};
875 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
876}

◆ TEST() [14/80]

TEST ( ringct ,
fee_non_0_invalid_lower_simple  )

Definition at line 878 of file ringct.cpp.

879{
880 const uint64_t inputs[] = {1000, 1000};
881 const uint64_t outputs[] = {1000, 100};
882 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
883}

◆ TEST() [15/80]

TEST ( ringct ,
fee_non_0_valid  )

Definition at line 843 of file ringct.cpp.

844{
845 const uint64_t inputs[] = {2000};
846 const uint64_t outputs[] = {1900, 100};
847 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, false));
848}

◆ TEST() [16/80]

TEST ( ringct ,
fee_non_0_valid_simple  )

Definition at line 850 of file ringct.cpp.

851{
852 const uint64_t inputs[] = {1000, 1000};
853 const uint64_t outputs[] = {1900, 100};
854 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, true, true));
855}

◆ TEST() [17/80]

TEST ( ringct ,
H  )

Definition at line 1059 of file ringct.cpp.

1060{
1061 ge_p3 p3;
1062 ASSERT_EQ(ge_frombytes_vartime(&p3, rct::H.bytes), 0);
1063 ASSERT_EQ(memcmp(&p3, &ge_p3_H, sizeof(ge_p3)), 0);
1064}
ge_p3_H
const ge_p3 ge_p3_H
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition gtest.h:1956
crypto::ge_frombytes_vartime
int ge_frombytes_vartime(ge_p3 *, const unsigned char *)
ge_p3
Definition crypto-ops.h:46
Here is the call graph for this function:

◆ TEST() [18/80]

TEST ( ringct ,
HPow2  )

Definition at line 788 of file ringct.cpp.

789{
790 key G = scalarmultBase(d2h(1));
791
792 key H = hashToPointSimple(G);
793 for (int j = 0 ; j < ATOMS ; j++) {
794 ASSERT_TRUE(equalKeys(H, H2[j]));
795 addKeys(H, H, H);
796 }
797}
crypto::addKeys
public_key addKeys(const public_key &A, const public_key &B)
Definition crypto.h:339
rct::hashToPointSimple
key hashToPointSimple(const key &hh)
Definition rctOps.cpp:624
rct::equalKeys
bool equalKeys(const key &a, const key &b)
Definition rctOps.cpp:519
ATOMS
#define ATOMS
Definition rctTypes.h:65
Here is the call graph for this function:

◆ TEST() [19/80]

TEST ( ringct ,
key_ostream  )

Definition at line 1020 of file ringct.cpp.

1021{
1022 std::stringstream out;
1023 out << "BEGIN" << rct::H << "END";
1024 EXPECT_EQ(
1025 std::string{"BEGIN<8b655970153799af2aeadc9ff1add0ea6c7251d54154cfa92c173a0dd39c1f94>END"},
1026 out.str()
1027 );
1028}
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition gtest.h:1922

◆ TEST() [20/80]

TEST ( ringct ,
MG_sigs  )

Definition at line 90 of file ringct.cpp.

91{
92 int j = 0;
93 int N = 0;
94
95 //Tests for MG Sigs
96 //#MG sig: true one
97 N = 3;// #cols
98 int R = 3;// #rows
99 keyV xtmp = skvGen(R);
100 keyM xm = keyMInit(R, N);// = [[None]*N] #just used to generate test public keys
101 keyV sk = skvGen(R);
102 keyM P = keyMInit(R, N);// = keyM[[None]*N] #stores the public keys;
103 int ind = 2;
104 int i = 0;
105 for (j = 0 ; j < R ; j++) {
106 for (i = 0 ; i < N ; i++)
107 {
108 xm[i][j] = skGen();
109 P[i][j] = scalarmultBase(xm[i][j]);
110 }
111 }
112 for (j = 0 ; j < R ; j++) {
113 sk[j] = xm[ind][j];
114 }
115 key message = identity();
116 mgSig IIccss = MLSAG_Gen(message, P, sk, NULL, NULL, ind, R, hw::get_device("default"));
117 ASSERT_TRUE(MLSAG_Ver(message, P, IIccss, R));
118
119 //#MG sig: false one
120 N = 3;// #cols
121 R = 3;// #rows
122 xtmp = skvGen(R);
123 keyM xx(N, xtmp);// = [[None]*N] #just used to generate test public keys
124 sk = skvGen(R);
125 //P (N, xtmp);// = keyM[[None]*N] #stores the public keys;
126
127 ind = 2;
128 for (j = 0 ; j < R ; j++) {
129 for (i = 0 ; i < N ; i++)
130 {
131 xx[i][j] = skGen();
132 P[i][j] = scalarmultBase(xx[i][j]);
133 }
134 sk[j] = xx[ind][j];
135 }
136 sk[2] = skGen();//assume we don't know one of the private keys..
137 IIccss = MLSAG_Gen(message, P, sk, NULL, NULL, ind, R, hw::get_device("default"));
138 ASSERT_FALSE(MLSAG_Ver(message, P, IIccss, R));
139}
message
std::string message("Message requiring signing")
hw::get_device
device & get_device(const std::string &device_descriptor)
Definition device.cpp:95
rct::keyV
std::vector< key > keyV
Definition rctTypes.h:88
rct::keyM
std::vector< keyV > keyM
Definition rctTypes.h:89
rct::skvGen
keyV skvGen(size_t rows)
Definition rctOps.cpp:266
rct::MLSAG_Gen
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)
Definition rctSigs.cpp:174
rct::MLSAG_Ver
bool MLSAG_Ver(const key &message, const keyM &pk, const mgSig &rv, size_t dsRows)
Definition rctSigs.cpp:271
rct::keyMInit
keyM keyMInit(size_t rows, size_t cols)
Definition rctOps.cpp:227
rct::identity
key identity()
Definition rctOps.h:73
Here is the call graph for this function:

◆ TEST() [21/80]

TEST ( ringct ,
mul8  )

Definition at line 1066 of file ringct.cpp.

1067{
1068 ASSERT_EQ(rct::scalarmult8(rct::identity()), rct::identity());
1069 ASSERT_EQ(rct::scalarmult8(rct::H), rct::scalarmultKey(rct::H, rct::EIGHT));
1070 ASSERT_EQ(rct::scalarmultKey(rct::scalarmultKey(rct::H, rct::INV_EIGHT), rct::EIGHT), rct::H);
1071}
rct::scalarmultKey
void scalarmultKey(key &aP, const key &P, const key &a)
Definition rctOps.cpp:368
rct::scalarmult8
key scalarmult8(const key &P)
Definition rctOps.cpp:398
Here is the call graph for this function:

◆ TEST() [22/80]

TEST ( ringct ,
prooveRange_is_non_deterministic  )

Definition at line 820 of file ringct.cpp.

821{
822 key C[2], mask[2];
823 for (int n = 0; n < 2; ++n)
824 proveRange(C[n], mask[n], 80);
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)));
827}
rct::proveRange
rangeSig proveRange(key &C, key &mask, const etn_amount &amount)
Definition rctSigs.cpp:336
Here is the call graph for this function:

◆ TEST() [23/80]

TEST ( ringct ,
range_proofs  )

Definition at line 141 of file ringct.cpp.

142{
143 //Ring CT Stuff
144 //ct range proofs
145 ctkeyV sc, pc;
146 ctkey sctmp, pctmp;
147 std::vector<uint64_t> inamounts;
148 //add fake input 6000
149 inamounts.push_back(6000);
150 tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
151 sc.push_back(sctmp);
152 pc.push_back(pctmp);
153
154
155 inamounts.push_back(7000);
156 tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
157 sc.push_back(sctmp);
158 pc.push_back(pctmp);
159 vector<etn_amount >amounts;
160 rct::keyV amount_keys;
161 key mask;
162
163 //add output 500
164 amounts.push_back(500);
165 amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
166 keyV destinations;
167 key Sk, Pk;
168 skpkGen(Sk, Pk);
169 destinations.push_back(Pk);
170
171
172 //add output for 12500
173 amounts.push_back(12500);
174 amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
175 skpkGen(Sk, Pk);
176 destinations.push_back(Pk);
177
178 const rct::RCTConfig rct_config { RangeProofBorromean, 0 };
179
180 //compute rct data with mixin 3 - should fail since full type with > 1 input
181 bool ok = false;
182 try { genRct(rct::zero(), sc, pc, destinations, amounts, amount_keys, NULL, NULL, 3, rct_config, hw::get_device("default")); }
183 catch(...) { ok = true; }
184 ASSERT_TRUE(ok);
185
186 //compute rct data with mixin 3
187 rctSig s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config, hw::get_device("default"));
188
189 //verify rct data
190 ASSERT_TRUE(verRctSimple(s));
191
192 //decode received amount
193 decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
194
195 // Ring CT with failing MG sig part should not verify!
196 // Since sum of inputs != outputs
197
198 amounts[1] = 12501;
199 skpkGen(Sk, Pk);
200 destinations[1] = Pk;
201
202
203 //compute rct data with mixin 3
204 s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 0, 3, rct_config, hw::get_device("default"));
205
206 //verify rct data
207 ASSERT_FALSE(verRctSimple(s));
208
209 //decode received amount
210 decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
211}
rct::hash_to_scalar
void hash_to_scalar(key &hash, const void *data, const std::size_t l)
Definition rctOps.cpp:536
rct::decodeRctSimple
etn_amount decodeRctSimple(const rctSig &rv, const key &sk, unsigned int i, key &mask, hw::device &hwdev)
Definition rctSigs.cpp:1180
rct::genRct
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)
Definition rctSigs.cpp:690
rct::ctkeyV
std::vector< ctkey > ctkeyV
Definition rctTypes.h:100
rct::zero
key zero()
Definition rctOps.h:70
rct::ctskpkGen
tuple< ctkey, ctkey > ctskpkGen(etn_amount amount)
Definition rctOps.cpp:302
rct::RangeProofBorromean
@ RangeProofBorromean
Definition rctTypes.h:235
rct::genRctSimple
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)
Definition rctSigs.cpp:752
Here is the call graph for this function:

◆ TEST() [24/80]

TEST ( ringct ,
range_proofs_accept_1_to_1  )

Definition at line 732 of file ringct.cpp.

733{
734 const uint64_t inputs[] = {5000};
735 const uint64_t outputs[] = {5000};
736 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
737}

◆ TEST() [25/80]

TEST ( ringct ,
range_proofs_accept_1_to_1_simple  )

Definition at line 739 of file ringct.cpp.

740{
741 const uint64_t inputs[] = {5000};
742 const uint64_t outputs[] = {5000};
743 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
744}

◆ TEST() [26/80]

TEST ( ringct ,
range_proofs_accept_1_to_N  )

Definition at line 746 of file ringct.cpp.

747{
748 const uint64_t inputs[] = {5000};
749 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
750 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
751}

◆ TEST() [27/80]

TEST ( ringct ,
range_proofs_accept_1_to_N_simple  )

Definition at line 753 of file ringct.cpp.

754{
755 const uint64_t inputs[] = {5000};
756 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
757 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false,true));
758}

◆ TEST() [28/80]

TEST ( ringct ,
range_proofs_accept_N_to_1_simple  )

Definition at line 760 of file ringct.cpp.

761{
762 const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
763 const uint64_t outputs[] = {5000};
764 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
765}

◆ TEST() [29/80]

TEST ( ringct ,
range_proofs_accept_N_to_N_simple  )

Definition at line 767 of file ringct.cpp.

768{
769 const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
770 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000};
771 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
772}

◆ TEST() [30/80]

TEST ( ringct ,
range_proofs_accept_very_long_simple  )

Definition at line 774 of file ringct.cpp.

775{
776 const size_t N=12;
777 uint64_t inputs[N];
778 uint64_t outputs[N];
779 for (size_t n = 0; n < N; ++n) {
780 inputs[n] = n;
781 outputs[n] = n;
782 }
783 std::random_shuffle(inputs, inputs + N);
784 std::random_shuffle(outputs, outputs + N);
785 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
786}

◆ TEST() [31/80]

TEST ( ringct ,
range_proofs_accept_zero  )

Definition at line 550 of file ringct.cpp.

551{
552 const uint64_t inputs[] = {0};
553 const uint64_t outputs[] = {0};
554 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
555}

◆ TEST() [32/80]

TEST ( ringct ,
range_proofs_accept_zero_empty  )

Definition at line 466 of file ringct.cpp.

467{
468 const uint64_t inputs[] = {0};
469 const uint64_t outputs[] = {};
470 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
471}

◆ TEST() [33/80]

TEST ( ringct ,
range_proofs_accept_zero_empty_simple  )

Definition at line 473 of file ringct.cpp.

474{
475 const uint64_t inputs[] = {0};
476 const uint64_t outputs[] = {};
477 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
478}

◆ TEST() [34/80]

TEST ( ringct ,
range_proofs_accept_zero_in_first_simple  )

Definition at line 557 of file ringct.cpp.

558{
559 const uint64_t inputs[] = {0, 5000};
560 const uint64_t outputs[] = {5000};
561 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
562}

◆ TEST() [35/80]

TEST ( ringct ,
range_proofs_accept_zero_in_last_simple  )

Definition at line 564 of file ringct.cpp.

565{
566 const uint64_t inputs[] = {5000, 0};
567 const uint64_t outputs[] = {5000};
568 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
569}

◆ TEST() [36/80]

TEST ( ringct ,
range_proofs_accept_zero_in_middle_simple  )

Definition at line 571 of file ringct.cpp.

572{
573 const uint64_t inputs[] = {2500, 0, 2500};
574 const uint64_t outputs[] = {5000};
575 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
576}

◆ TEST() [37/80]

TEST ( ringct ,
range_proofs_accept_zero_out_first  )

Definition at line 508 of file ringct.cpp.

509{
510 const uint64_t inputs[] = {5000};
511 const uint64_t outputs[] = {0, 5000};
512 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
513}

◆ TEST() [38/80]

TEST ( ringct ,
range_proofs_accept_zero_out_first_simple  )

Definition at line 515 of file ringct.cpp.

516{
517 const uint64_t inputs[] = {5000};
518 const uint64_t outputs[] = {0, 5000};
519 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
520}

◆ TEST() [39/80]

TEST ( ringct ,
range_proofs_accept_zero_out_last  )

Definition at line 522 of file ringct.cpp.

523{
524 const uint64_t inputs[] = {5000};
525 const uint64_t outputs[] = {5000, 0};
526 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
527}

◆ TEST() [40/80]

TEST ( ringct ,
range_proofs_accept_zero_out_last_simple  )

Definition at line 529 of file ringct.cpp.

530{
531 const uint64_t inputs[] = {5000};
532 const uint64_t outputs[] = {5000, 0};
533 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
534}

◆ TEST() [41/80]

TEST ( ringct ,
range_proofs_accept_zero_out_middle  )

Definition at line 536 of file ringct.cpp.

537{
538 const uint64_t inputs[] = {5000};
539 const uint64_t outputs[] = {2500, 0, 2500};
540 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
541}

◆ TEST() [42/80]

TEST ( ringct ,
range_proofs_accept_zero_out_middle_simple  )

Definition at line 543 of file ringct.cpp.

544{
545 const uint64_t inputs[] = {5000};
546 const uint64_t outputs[] = {2500, 0, 2500};
547 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
548}

◆ TEST() [43/80]

TEST ( ringct ,
range_proofs_accept_zero_zero  )

Definition at line 494 of file ringct.cpp.

495{
496 const uint64_t inputs[] = {0};
497 const uint64_t outputs[] = {0};
498 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
499}

◆ TEST() [44/80]

TEST ( ringct ,
range_proofs_accept_zero_zero_simple  )

Definition at line 501 of file ringct.cpp.

502{
503 const uint64_t inputs[] = {0};
504 const uint64_t outputs[] = {0};
505 EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
506}

◆ TEST() [45/80]

TEST ( ringct ,
range_proofs_reject_all_empty  )

Definition at line 452 of file ringct.cpp.

453{
454 const uint64_t inputs[] = {};
455 const uint64_t outputs[] = {};
456 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
457}

◆ TEST() [46/80]

TEST ( ringct ,
range_proofs_reject_all_empty_simple  )

Definition at line 459 of file ringct.cpp.

460{
461 const uint64_t inputs[] = {};
462 const uint64_t outputs[] = {};
463 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
464}

◆ TEST() [47/80]

TEST ( ringct ,
range_proofs_reject_empty_ins  )

Definition at line 438 of file ringct.cpp.

439{
440 const uint64_t inputs[] = {};
441 const uint64_t outputs[] = {5000};
442 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
443}

◆ TEST() [48/80]

TEST ( ringct ,
range_proofs_reject_empty_ins_simple  )

Definition at line 445 of file ringct.cpp.

446{
447 const uint64_t inputs[] = {};
448 const uint64_t outputs[] = {5000};
449 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
450}

◆ TEST() [49/80]

TEST ( ringct ,
range_proofs_reject_empty_outs  )

Definition at line 424 of file ringct.cpp.

425{
426 const uint64_t inputs[] = {5000};
427 const uint64_t outputs[] = {};
428 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
429}

◆ TEST() [50/80]

TEST ( ringct ,
range_proofs_reject_empty_outs_simple  )

Definition at line 431 of file ringct.cpp.

432{
433 const uint64_t inputs[] = {5000};
434 const uint64_t outputs[] = {};
435 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
436}

◆ TEST() [51/80]

TEST ( ringct ,
range_proofs_reject_empty_zero  )

Definition at line 480 of file ringct.cpp.

481{
482 const uint64_t inputs[] = {};
483 const uint64_t outputs[] = {0};
484 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
485}

◆ TEST() [52/80]

TEST ( ringct ,
range_proofs_reject_empty_zero_simple  )

Definition at line 487 of file ringct.cpp.

488{
489 const uint64_t inputs[] = {};
490 const uint64_t outputs[] = {0};
491 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
492}

◆ TEST() [53/80]

TEST ( ringct ,
range_proofs_reject_higher_list  )

Definition at line 718 of file ringct.cpp.

719{
720 const uint64_t inputs[] = {5000};
721 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
722 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
723}

◆ TEST() [54/80]

TEST ( ringct ,
range_proofs_reject_higher_list_simple  )

Definition at line 725 of file ringct.cpp.

726{
727 const uint64_t inputs[] = {5000};
728 const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
729 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
730}

◆ TEST() [55/80]

TEST ( ringct ,
range_proofs_reject_in_negative_first  )

Definition at line 676 of file ringct.cpp.

677{
678 const uint64_t inputs[] = {(uint64_t)-1000ll, 6000};
679 const uint64_t outputs[] = {5000};
680 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
681}

◆ TEST() [56/80]

TEST ( ringct ,
range_proofs_reject_in_negative_first_simple  )

Definition at line 683 of file ringct.cpp.

684{
685 const uint64_t inputs[] = {(uint64_t)-1000ll, 6000};
686 const uint64_t outputs[] = {5000};
687 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
688}

◆ TEST() [57/80]

TEST ( ringct ,
range_proofs_reject_in_negative_last  )

Definition at line 690 of file ringct.cpp.

691{
692 const uint64_t inputs[] = {6000, (uint64_t)-1000ll};
693 const uint64_t outputs[] = {5000};
694 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
695}

◆ TEST() [58/80]

TEST ( ringct ,
range_proofs_reject_in_negative_last_simple  )

Definition at line 697 of file ringct.cpp.

698{
699 const uint64_t inputs[] = {6000, (uint64_t)-1000ll};
700 const uint64_t outputs[] = {5000};
701 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
702}

◆ TEST() [59/80]

TEST ( ringct ,
range_proofs_reject_in_negative_middle  )

Definition at line 704 of file ringct.cpp.

705{
706 const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000};
707 const uint64_t outputs[] = {5000};
708 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
709}

◆ TEST() [60/80]

TEST ( ringct ,
range_proofs_reject_in_negative_middle_simple  )

Definition at line 711 of file ringct.cpp.

712{
713 const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000};
714 const uint64_t outputs[] = {5000};
715 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
716}

◆ TEST() [61/80]

TEST ( ringct ,
range_proofs_reject_out_negative_first  )

Definition at line 620 of file ringct.cpp.

621{
622 const uint64_t inputs[] = {5000};
623 const uint64_t outputs[] = {(uint64_t)-1000ll, 6000};
624 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
625}

◆ TEST() [62/80]

TEST ( ringct ,
range_proofs_reject_out_negative_first_simple  )

Definition at line 627 of file ringct.cpp.

628{
629 const uint64_t inputs[] = {5000};
630 const uint64_t outputs[] = {(uint64_t)-1000ll, 6000};
631 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
632}

◆ TEST() [63/80]

TEST ( ringct ,
range_proofs_reject_out_negative_last  )

Definition at line 634 of file ringct.cpp.

635{
636 const uint64_t inputs[] = {5000};
637 const uint64_t outputs[] = {6000, (uint64_t)-1000ll};
638 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
639}

◆ TEST() [64/80]

TEST ( ringct ,
range_proofs_reject_out_negative_last_simple  )

Definition at line 641 of file ringct.cpp.

642{
643 const uint64_t inputs[] = {5000};
644 const uint64_t outputs[] = {6000, (uint64_t)-1000ll};
645 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
646}

◆ TEST() [65/80]

TEST ( ringct ,
range_proofs_reject_out_negative_middle  )

Definition at line 648 of file ringct.cpp.

649{
650 const uint64_t inputs[] = {5000};
651 const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000};
652 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
653}

◆ TEST() [66/80]

TEST ( ringct ,
range_proofs_reject_out_negative_middle_simple  )

Definition at line 655 of file ringct.cpp.

656{
657 const uint64_t inputs[] = {5000};
658 const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000};
659 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
660}

◆ TEST() [67/80]

TEST ( ringct ,
range_proofs_reject_single_higher  )

Definition at line 592 of file ringct.cpp.

593{
594 const uint64_t inputs[] = {5000};
595 const uint64_t outputs[] = {5001};
596 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
597}

◆ TEST() [68/80]

TEST ( ringct ,
range_proofs_reject_single_higher_simple  )

Definition at line 599 of file ringct.cpp.

600{
601 const uint64_t inputs[] = {5000};
602 const uint64_t outputs[] = {5001};
603 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
604}

◆ TEST() [69/80]

TEST ( ringct ,
range_proofs_reject_single_in_negative  )

Definition at line 662 of file ringct.cpp.

663{
664 const uint64_t inputs[] = {(uint64_t)-1000ll};
665 const uint64_t outputs[] = {5000};
666 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
667}

◆ TEST() [70/80]

TEST ( ringct ,
range_proofs_reject_single_in_negative_simple  )

Definition at line 669 of file ringct.cpp.

670{
671 const uint64_t inputs[] = {(uint64_t)-1000ll};
672 const uint64_t outputs[] = {5000};
673 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
674}

◆ TEST() [71/80]

TEST ( ringct ,
range_proofs_reject_single_lower  )

Definition at line 578 of file ringct.cpp.

579{
580 const uint64_t inputs[] = {5000};
581 const uint64_t outputs[] = {1};
582 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
583}

◆ TEST() [72/80]

TEST ( ringct ,
range_proofs_reject_single_lower_simple  )

Definition at line 585 of file ringct.cpp.

586{
587 const uint64_t inputs[] = {5000};
588 const uint64_t outputs[] = {1};
589 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
590}

◆ TEST() [73/80]

TEST ( ringct ,
range_proofs_reject_single_out_negative  )

Definition at line 606 of file ringct.cpp.

607{
608 const uint64_t inputs[] = {5000};
609 const uint64_t outputs[] = {(uint64_t)-1000ll};
610 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, false));
611}

◆ TEST() [74/80]

TEST ( ringct ,
range_proofs_reject_single_out_negative_simple  )

Definition at line 613 of file ringct.cpp.

614{
615 const uint64_t inputs[] = {5000};
616 const uint64_t outputs[] = {(uint64_t)-1000ll};
617 EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false, true));
618}

◆ TEST() [75/80]

TEST ( ringct ,
range_proofs_with_fee  )

Definition at line 213 of file ringct.cpp.

214{
215 //Ring CT Stuff
216 //ct range proofs
217 ctkeyV sc, pc;
218 ctkey sctmp, pctmp;
219 std::vector<uint64_t> inamounts;
220 //add fake input 6001
221 inamounts.push_back(6001);
222 tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
223 sc.push_back(sctmp);
224 pc.push_back(pctmp);
225
226
227 inamounts.push_back(7000);
228 tie(sctmp, pctmp) = ctskpkGen(inamounts.back());
229 sc.push_back(sctmp);
230 pc.push_back(pctmp);
231 vector<etn_amount >amounts;
232 keyV amount_keys;
233 key mask;
234
235 //add output 500
236 amounts.push_back(500);
237 amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
238 keyV destinations;
239 key Sk, Pk;
240 skpkGen(Sk, Pk);
241 destinations.push_back(Pk);
242
243 //add output for 12500
244 amounts.push_back(12500);
245 amount_keys.push_back(hash_to_scalar(zero()));
246 skpkGen(Sk, Pk);
247 destinations.push_back(Pk);
248
249 const rct::RCTConfig rct_config { RangeProofBorromean, 0 };
250
251 //compute rct data with mixin 3
252 rctSig s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 1, 3, rct_config, hw::get_device("default"));
253
254 //verify rct data
255 ASSERT_TRUE(verRctSimple(s));
256
257 //decode received amount
258 decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
259
260 // Ring CT with failing MG sig part should not verify!
261 // Since sum of inputs != outputs
262
263 amounts[1] = 12501;
264 skpkGen(Sk, Pk);
265 destinations[1] = Pk;
266
267
268 //compute rct data with mixin 3
269 s = genRctSimple(rct::zero(), sc, pc, destinations, inamounts, amounts, amount_keys, NULL, NULL, 500, 3, rct_config, hw::get_device("default"));
270
271 //verify rct data
272 ASSERT_FALSE(verRctSimple(s));
273
274 //decode received amount
275 decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
276}
crypto::hash_to_scalar
void hash_to_scalar(const void *data, size_t length, ec_scalar &res)
Definition crypto.cpp:126
Here is the call graph for this function:

◆ TEST() [76/80]

TEST ( ringct ,
reject_gen_non_simple_ver_simple  )

Definition at line 1012 of file ringct.cpp.

1013{
1014 const uint64_t inputs[] = {2000};
1015 const uint64_t outputs[] = {1000, 1000};
1016 rct::rctSig sig = make_sample_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, true);
1017 ASSERT_FALSE(rct::verRctSimple(sig));
1018}

◆ TEST() [77/80]

TEST ( ringct ,
reject_gen_simple_ver_non_simple  )

Definition at line 1004 of file ringct.cpp.

1005{
1006 const uint64_t inputs[] = {1000, 1000};
1007 const uint64_t outputs[] = {1000};
1008 rct::rctSig sig = make_sample_simple_rct_sig(NELTS(inputs), inputs, NELTS(outputs), outputs, 1000);
1009 ASSERT_FALSE(rct::verRct(sig));
1010}
Here is the call graph for this function:

◆ TEST() [78/80]

TEST ( ringct ,
simple  )

Definition at line 278 of file ringct.cpp.

279{
280 ctkeyV sc, pc;
281 ctkey sctmp, pctmp;
282 //this vector corresponds to output amounts
283 vector<etn_amount>outamounts;
284 //this vector corresponds to input amounts
285 vector<etn_amount>inamounts;
286 //this keyV corresponds to destination pubkeys
287 keyV destinations;
288 keyV amount_keys;
289 key mask;
290
291 //add fake input 3000
292 //the sc is secret data
293 //pc is public data
294 tie(sctmp, pctmp) = ctskpkGen(3000);
295 sc.push_back(sctmp);
296 pc.push_back(pctmp);
297 inamounts.push_back(3000);
298
299 //add fake input 3000
300 //the sc is secret data
301 //pc is public data
302 tie(sctmp, pctmp) = ctskpkGen(3000);
303 sc.push_back(sctmp);
304 pc.push_back(pctmp);
305 inamounts.push_back(3000);
306
307 //add output 5000
308 outamounts.push_back(5000);
309 amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
310 //add the corresponding destination pubkey
311 key Sk, Pk;
312 skpkGen(Sk, Pk);
313 destinations.push_back(Pk);
314
315 //add output 999
316 outamounts.push_back(999);
317 amount_keys.push_back(rct::hash_to_scalar(rct::zero()));
318 //add the corresponding destination pubkey
319 skpkGen(Sk, Pk);
320 destinations.push_back(Pk);
321
322 key message = skGen(); //real message later (hash of txn..)
323
324 //compute sig with mixin 2
325 etn_amount txnfee = 1;
326
327 const rct::RCTConfig rct_config { RangeProofBorromean, 0 };
328 rctSig s = genRctSimple(message, sc, pc, destinations,inamounts, outamounts, amount_keys, NULL, NULL, txnfee, 2, rct_config, hw::get_device("default"));
329
330 //verify ring ct signature
331 ASSERT_TRUE(verRctSimple(s));
332
333 //decode received amount corresponding to output pubkey index 1
334 decodeRctSimple(s, amount_keys[1], 1, mask, hw::get_device("default"));
335}
rct::etn_amount
uint64_t etn_amount
Definition rctTypes.h:135
Here is the call graph for this function:

◆ TEST() [79/80]

TEST ( ringct ,
zeroCommitCache  )

Definition at line 1047 of file ringct.cpp.

1048{
1049 ASSERT_EQ(rct::zeroCommit(0), uncachedZeroCommit(0));
1050 ASSERT_EQ(rct::zeroCommit(1), uncachedZeroCommit(1));
1051 ASSERT_EQ(rct::zeroCommit(2), uncachedZeroCommit(2));
1052 ASSERT_EQ(rct::zeroCommit(10), uncachedZeroCommit(10));
1053 ASSERT_EQ(rct::zeroCommit(200), uncachedZeroCommit(200));
1054 ASSERT_EQ(rct::zeroCommit(1000000000), uncachedZeroCommit(1000000000));
1055 ASSERT_EQ(rct::zeroCommit(3000000000000), uncachedZeroCommit(3000000000000));
1056 ASSERT_EQ(rct::zeroCommit(900000000000000), uncachedZeroCommit(900000000000000));
1057}
rct::zeroCommit
key zeroCommit(etn_amount amount)
Definition rctOps.cpp:322
Here is the call graph for this function:

◆ TEST() [80/80]

TEST ( ringct ,
zeroCommmit  )

Definition at line 1030 of file ringct.cpp.

1031{
1032 static const uint64_t amount = crypto::rand<uint64_t>();
1033 const rct::key z = rct::zeroCommit(amount);
1034 const rct::key a = rct::scalarmultBase(rct::identity());
1035 const rct::key b = rct::scalarmultH(rct::d2h(amount));
1036 const rct::key manual = rct::addKeys(a, b);
1037 ASSERT_EQ(z, manual);
1038}
crypto::rand
std::enable_if< std::is_pod< T >::value, T >::type rand()
Definition crypto.h:216
rct::scalarmultH
key scalarmultH(const key &a)
Definition rctOps.cpp:389
rct::addKeys
void addKeys(key &AB, const key &A, const key &B)
Definition rctOps.cpp:420
a
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
Definition pointer.h:1124
Here is the call graph for this function:

◆ TEST_rctSig_elements() [1/25]

TEST_rctSig_elements ( ecdhInfo_empty ,
sig.ecdhInfo. resize0 )

◆ TEST_rctSig_elements() [2/25]

TEST_rctSig_elements ( ecdhInfo_too_few ,
sig.ecdhInfo. pop_back() )

◆ TEST_rctSig_elements() [3/25]

TEST_rctSig_elements ( ecdhInfo_too_many ,
sig.ecdhInfo. push_backsig.ecdhInfo.back() )

◆ TEST_rctSig_elements() [4/25]

TEST_rctSig_elements ( mgSig_II_empty ,
sig.p.MGs.II. resize(0)[0] )

◆ TEST_rctSig_elements() [5/25]

TEST_rctSig_elements ( mgSig_II_too_few ,
sig.p.MGs.II. pop_back()[0] )

◆ TEST_rctSig_elements() [6/25]

TEST_rctSig_elements ( mgSig_II_too_many ,
sig.p.MGs.II. push_back(sig.p.MGs[0].II.back())[0] )

◆ TEST_rctSig_elements() [7/25]

TEST_rctSig_elements ( mgSig_MG_empty ,
sig.p.MGs. resize0 )

◆ TEST_rctSig_elements() [8/25]

TEST_rctSig_elements ( mgSig_ss0_empty ,
sig.p.MGs.ss. resize(0)[0][0] )

◆ TEST_rctSig_elements() [9/25]

TEST_rctSig_elements ( mgSig_ss0_too_few ,
sig.p.MGs.ss. pop_back()[0][0] )

◆ TEST_rctSig_elements() [10/25]

TEST_rctSig_elements ( mgSig_ss0_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss[0].back())[0][0] )

◆ TEST_rctSig_elements() [11/25]

TEST_rctSig_elements ( mgSig_ss_empty ,
sig.p.MGs.ss. resize(0)[0] )

◆ TEST_rctSig_elements() [12/25]

TEST_rctSig_elements ( mgSig_ss_too_few ,
sig.p.MGs.ss. pop_back()[0] )

◆ TEST_rctSig_elements() [13/25]

TEST_rctSig_elements ( mgSig_ss_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss.back())[0] )

◆ TEST_rctSig_elements() [14/25]

TEST_rctSig_elements ( mixRing0_empty ,
sig.mixRing. resize(0)[0] )

◆ TEST_rctSig_elements() [15/25]

TEST_rctSig_elements ( mixRing0_too_few ,
sig.mixRing. pop_back()[0] )

◆ TEST_rctSig_elements() [16/25]

TEST_rctSig_elements ( mixRing0_too_many ,
sig.mixRing. push_back(sig.mixRing[0].back())[0] )

◆ TEST_rctSig_elements() [17/25]

TEST_rctSig_elements ( mixRing_empty ,
sig.mixRing. resize0 )

◆ TEST_rctSig_elements() [18/25]

TEST_rctSig_elements ( mixRing_too_few ,
sig.mixRing. pop_back() )

◆ TEST_rctSig_elements() [19/25]

TEST_rctSig_elements ( mixRing_too_many ,
sig.mixRing. push_backsig.mixRing.back() )

◆ TEST_rctSig_elements() [20/25]

TEST_rctSig_elements ( outPk_empty ,
sig.outPk. resize0 )

◆ TEST_rctSig_elements() [21/25]

TEST_rctSig_elements ( outPk_too_few ,
sig.outPk. pop_back() )

◆ TEST_rctSig_elements() [22/25]

TEST_rctSig_elements ( outPk_too_many ,
sig.outPk. push_backsig.outPk.back() )

◆ TEST_rctSig_elements() [23/25]

TEST_rctSig_elements ( rangeSigs_empty ,
sig.p.rangeSigs. resize0 )

◆ TEST_rctSig_elements() [24/25]

TEST_rctSig_elements ( rangeSigs_too_few ,
sig.p.rangeSigs. pop_back() )

◆ TEST_rctSig_elements() [25/25]

TEST_rctSig_elements ( rangeSigs_too_many ,
sig.p.rangeSigs. push_backsig.p.rangeSigs.back() )

◆ TEST_rctSig_elements_simple() [1/30]

TEST_rctSig_elements_simple ( ecdhInfo_empty ,
sig.ecdhInfo. resize0 )

◆ TEST_rctSig_elements_simple() [2/30]

TEST_rctSig_elements_simple ( ecdhInfo_too_few ,
sig.ecdhInfo. pop_back() )

◆ TEST_rctSig_elements_simple() [3/30]

TEST_rctSig_elements_simple ( ecdhInfo_too_many ,
sig.ecdhInfo. push_backsig.ecdhInfo.back() )

◆ TEST_rctSig_elements_simple() [4/30]

TEST_rctSig_elements_simple ( mgSig0_II_empty ,
sig.p.MGs.II. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [5/30]

TEST_rctSig_elements_simple ( mgSig0_II_too_few ,
sig.p.MGs.II. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [6/30]

TEST_rctSig_elements_simple ( mgSig0_II_too_many ,
sig.p.MGs.II. push_back(sig.p.MGs[0].II.back())[0] )

◆ TEST_rctSig_elements_simple() [7/30]

TEST_rctSig_elements_simple ( mgSig0_ss_empty ,
sig.p.MGs.ss. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [8/30]

TEST_rctSig_elements_simple ( mgSig0_ss_too_few ,
sig.p.MGs.ss. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [9/30]

TEST_rctSig_elements_simple ( mgSig0_ss_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss.back())[0] )

◆ TEST_rctSig_elements_simple() [10/30]

TEST_rctSig_elements_simple ( mgSig_empty ,
sig.p.MGs. resize0 )

◆ TEST_rctSig_elements_simple() [11/30]

TEST_rctSig_elements_simple ( mgSig_ss0_empty ,
sig.p.MGs.ss. resize(0)[0][0] )

◆ TEST_rctSig_elements_simple() [12/30]

TEST_rctSig_elements_simple ( mgSig_ss0_too_few ,
sig.p.MGs.ss. pop_back()[0][0] )

◆ TEST_rctSig_elements_simple() [13/30]

TEST_rctSig_elements_simple ( mgSig_ss0_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss[0].back())[0][0] )

◆ TEST_rctSig_elements_simple() [14/30]

TEST_rctSig_elements_simple ( mgSig_too_few ,
sig.p.MGs. pop_back() )

◆ TEST_rctSig_elements_simple() [15/30]

TEST_rctSig_elements_simple ( mgSig_too_many ,
sig.p.MGs. push_backsig.p.MGs.back() )

◆ TEST_rctSig_elements_simple() [16/30]

TEST_rctSig_elements_simple ( mixRing0_empty ,
sig.mixRing. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [17/30]

TEST_rctSig_elements_simple ( mixRing0_too_few ,
sig.mixRing. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [18/30]

TEST_rctSig_elements_simple ( mixRing0_too_many ,
sig.mixRing. push_back(sig.mixRing[0].back())[0] )

◆ TEST_rctSig_elements_simple() [19/30]

TEST_rctSig_elements_simple ( mixRing_empty ,
sig.mixRing. resize0 )

◆ TEST_rctSig_elements_simple() [20/30]

TEST_rctSig_elements_simple ( mixRing_too_few ,
sig.mixRing. pop_back() )

◆ TEST_rctSig_elements_simple() [21/30]

TEST_rctSig_elements_simple ( mixRing_too_many ,
sig.mixRing. push_backsig.mixRing.back() )

◆ TEST_rctSig_elements_simple() [22/30]

TEST_rctSig_elements_simple ( outPk_empty ,
sig.outPk. resize0 )

◆ TEST_rctSig_elements_simple() [23/30]

TEST_rctSig_elements_simple ( outPk_too_few ,
sig.outPk. pop_back() )

◆ TEST_rctSig_elements_simple() [24/30]

TEST_rctSig_elements_simple ( outPk_too_many ,
sig.outPk. push_backsig.outPk.back() )

◆ TEST_rctSig_elements_simple() [25/30]

TEST_rctSig_elements_simple ( pseudoOuts_empty ,
sig.pseudoOuts. resize0 )

◆ TEST_rctSig_elements_simple() [26/30]

TEST_rctSig_elements_simple ( pseudoOuts_too_few ,
sig.pseudoOuts. pop_back() )

◆ TEST_rctSig_elements_simple() [27/30]

TEST_rctSig_elements_simple ( pseudoOuts_too_many ,
sig.pseudoOuts. push_backsig.pseudoOuts.back() )

◆ TEST_rctSig_elements_simple() [28/30]

TEST_rctSig_elements_simple ( rangeSigs_empty ,
sig.p.rangeSigs. resize0 )

◆ TEST_rctSig_elements_simple() [29/30]

TEST_rctSig_elements_simple ( rangeSigs_too_few ,
sig.p.rangeSigs. pop_back() )

◆ TEST_rctSig_elements_simple() [30/30]

TEST_rctSig_elements_simple ( rangeSigs_too_many ,
sig.p.rangeSigs. push_backsig.p.rangeSigs.back() )