monero-project/monero
monero-project/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-11-18 10:01:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

ringct: allow no outputs, and add tests for this and fees

Browse source
This commit is contained in:
moneromooo-monero 2016-06-14 17:15:49 +01:00
parent e99904ac31
commit 54f7429cf6
No known key found for this signature in database
GPG key ID: 686F07454D6CEFC3
2 changed files with 75 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/ringct/rctSigs.cpp
View file

@ -471,7 +471,6 @@ namespace rct {
// Note: For txn fees, the last index in the amounts vector should contain that // Note: For txn fees, the last index in the amounts vector should contain that
// Thus the amounts vector will be "one" longer than the destinations vectort // Thus the amounts vector will be "one" longer than the destinations vectort
rctSig genRct(const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> amounts, const ctkeyM &mixRing, unsigned int index) { rctSig genRct(const ctkeyV & inSk, const keyV & destinations, const vector<xmr_amount> amounts, const ctkeyM &mixRing, unsigned int index) {
CHECK_AND_ASSERT_THROW_MES(amounts.size() > 0, "Amounts must not be empty");
CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations"); CHECK_AND_ASSERT_THROW_MES(amounts.size() == destinations.size() || amounts.size() == destinations.size() + 1, "Different number of amounts/destinations");
CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing"); CHECK_AND_ASSERT_THROW_MES(index < mixRing.size(), "Bad index into mixRing");
for (size_t n = 0; n < mixRing.size(); ++n) { for (size_t n = 0; n < mixRing.size(); ++n) {
@ -536,7 +535,6 @@ namespace rct {
// uses the attached ecdh info to find the amounts represented by each output commitment // uses the attached ecdh info to find the amounts represented by each output commitment
// must know the destination private key to find the correct amount, else will return a random number // must know the destination private key to find the correct amount, else will return a random number
bool verRct(const rctSig & rv) { bool verRct(const rctSig & rv) {
CHECK_AND_ASSERT_THROW_MES(rv.rangeSigs.size() > 0, "Empty rv.rangeSigs");
CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.rangeSigs.size(), "Mismatched sizes of rv.outPk and rv.rangeSigs"); CHECK_AND_ASSERT_THROW_MES(rv.outPk.size() == rv.rangeSigs.size(), "Mismatched sizes of rv.outPk and rv.rangeSigs");
size_t i = 0; size_t i = 0;

104
tests/unit_tests/ringct.cpp
View file

@ -275,7 +275,7 @@ TEST(ringct, range_proofs_with_fee)
} }
static bool range_proof_test(bool expected_valid, static bool range_proof_test(bool expected_valid,
int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[]) int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee)
{ {
ctkeyV sc, pc; ctkeyV sc, pc;
ctkey sctmp, pctmp; ctkey sctmp, pctmp;
@ -292,6 +292,7 @@ static bool range_proof_test(bool expected_valid,
for (int n = 0; n < n_outputs; ++n) { for (int n = 0; n < n_outputs; ++n) {
amounts.push_back(output_amounts[n]); amounts.push_back(output_amounts[n]);
skpkGen(Sk, Pk); skpkGen(Sk, Pk);
if (n < n_outputs - 1 || !last_is_fee)
destinations.push_back(Pk); destinations.push_back(Pk);
} }
@ -319,189 +320,189 @@ TEST(ringct, range_proofs_reject_empty_outs)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {}; const uint64_t outputs[] = {};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_empty_ins) TEST(ringct, range_proofs_reject_empty_ins)
{ {
const uint64_t inputs[] = {}; const uint64_t inputs[] = {};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_all_empty) TEST(ringct, range_proofs_reject_all_empty)
{ {
const uint64_t inputs[] = {}; const uint64_t inputs[] = {};
const uint64_t outputs[] = {}; const uint64_t outputs[] = {};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_zero_empty) TEST(ringct, range_proofs_accept_zero_empty)
{ {
const uint64_t inputs[] = {0}; const uint64_t inputs[] = {0};
const uint64_t outputs[] = {}; const uint64_t outputs[] = {};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_empty_zero) TEST(ringct, range_proofs_reject_empty_zero)
{ {
const uint64_t inputs[] = {}; const uint64_t inputs[] = {};
const uint64_t outputs[] = {0}; const uint64_t outputs[] = {0};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_zero) TEST(ringct, range_proofs_accept_zero_zero)
{ {
const uint64_t inputs[] = {0}; const uint64_t inputs[] = {0};
const uint64_t outputs[] = {0}; const uint64_t outputs[] = {0};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_out_first) TEST(ringct, range_proofs_accept_zero_out_first)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {0, 5000}; const uint64_t outputs[] = {0, 5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_out_last) TEST(ringct, range_proofs_accept_zero_out_last)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {5000, 0}; const uint64_t outputs[] = {5000, 0};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_out_middle) TEST(ringct, range_proofs_accept_zero_out_middle)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {2500, 0, 2500}; const uint64_t outputs[] = {2500, 0, 2500};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_in_first) TEST(ringct, range_proofs_accept_zero_in_first)
{ {
const uint64_t inputs[] = {0, 5000}; const uint64_t inputs[] = {0, 5000};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_in_last) TEST(ringct, range_proofs_accept_zero_in_last)
{ {
const uint64_t inputs[] = {5000, 0}; const uint64_t inputs[] = {5000, 0};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_zero_in_middle) TEST(ringct, range_proofs_accept_zero_in_middle)
{ {
const uint64_t inputs[] = {2500, 0, 2500}; const uint64_t inputs[] = {2500, 0, 2500};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_single_lower) TEST(ringct, range_proofs_reject_single_lower)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {1}; const uint64_t outputs[] = {1};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_single_higher) TEST(ringct, range_proofs_reject_single_higher)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {5001}; const uint64_t outputs[] = {5001};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_single_out_negative) TEST(ringct, range_proofs_reject_single_out_negative)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {(uint64_t)-1000ll}; const uint64_t outputs[] = {(uint64_t)-1000ll};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_out_negative_first) TEST(ringct, range_proofs_reject_out_negative_first)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {(uint64_t)-1000ll, 6000}; const uint64_t outputs[] = {(uint64_t)-1000ll, 6000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_out_negative_last) TEST(ringct, range_proofs_reject_out_negative_last)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {6000, (uint64_t)-1000ll}; const uint64_t outputs[] = {6000, (uint64_t)-1000ll};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_out_negative_middle) TEST(ringct, range_proofs_reject_out_negative_middle)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000}; const uint64_t outputs[] = {3000, (uint64_t)-1000ll, 3000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_single_in_negative) TEST(ringct, range_proofs_reject_single_in_negative)
{ {
const uint64_t inputs[] = {(uint64_t)-1000ll}; const uint64_t inputs[] = {(uint64_t)-1000ll};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_in_negative_first) TEST(ringct, range_proofs_reject_in_negative_first)
{ {
const uint64_t inputs[] = {(uint64_t)-1000ll, 6000}; const uint64_t inputs[] = {(uint64_t)-1000ll, 6000};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_in_negative_last) TEST(ringct, range_proofs_reject_in_negative_last)
{ {
const uint64_t inputs[] = {6000, (uint64_t)-1000ll}; const uint64_t inputs[] = {6000, (uint64_t)-1000ll};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_in_negative_middle) TEST(ringct, range_proofs_reject_in_negative_middle)
{ {
const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000}; const uint64_t inputs[] = {3000, (uint64_t)-1000ll, 3000};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_reject_higher_list) TEST(ringct, range_proofs_reject_higher_list)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000}; const uint64_t outputs[] = {1000, 1000, 1000, 1000, 1000, 1000};
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_1_to_1) TEST(ringct, range_proofs_accept_1_to_1)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_1_to_N) TEST(ringct, range_proofs_accept_1_to_N)
{ {
const uint64_t inputs[] = {5000}; const uint64_t inputs[] = {5000};
const uint64_t outputs[] = {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)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_N_to_1) TEST(ringct, range_proofs_accept_N_to_1)
{ {
const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000}; const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
const uint64_t outputs[] = {5000}; const uint64_t outputs[] = {5000};
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_N_to_N) TEST(ringct, range_proofs_accept_N_to_N)
{ {
const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000}; const uint64_t inputs[] = {1000, 1000, 1000, 1000, 1000};
const uint64_t outputs[] = {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)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, range_proofs_accept_very_long) TEST(ringct, range_proofs_accept_very_long)
@ -515,7 +516,7 @@ TEST(ringct, range_proofs_accept_very_long)
} }
std::random_shuffle(inputs, inputs + N); std::random_shuffle(inputs, inputs + N);
std::random_shuffle(outputs, outputs + N); std::random_shuffle(outputs, outputs + N);
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs)); EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
} }
TEST(ringct, HPow2) TEST(ringct, HPow2)
@ -579,3 +580,46 @@ TEST(ringct, prooveRange_is_non_deterministic)
ASSERT_TRUE(memcmp(C[0].bytes, C[1].bytes, sizeof(C[0].bytes))); 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))); 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));
}
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));
}
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));
}
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));
}
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));
}
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));
}