|
|
|
@ -275,7 +275,7 @@ TEST(ringct, range_proofs_with_fee)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
ctkey sctmp, pctmp;
|
|
|
|
@ -292,7 +292,8 @@ static bool range_proof_test(bool expected_valid,
|
|
|
|
|
for (int n = 0; n < n_outputs; ++n) {
|
|
|
|
|
amounts.push_back(output_amounts[n]);
|
|
|
|
|
skpkGen(Sk, Pk);
|
|
|
|
|
destinations.push_back(Pk);
|
|
|
|
|
if (n < n_outputs - 1 || !last_is_fee)
|
|
|
|
|
destinations.push_back(Pk);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//compute rct data
|
|
|
|
@ -319,189 +320,189 @@ 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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
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 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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {0, 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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000, 0};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {2500, 0, 2500};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
const uint64_t inputs[] = {5000};
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(false, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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));
|
|
|
|
|
EXPECT_TRUE(range_proof_test(true, NELTS(inputs), inputs, NELTS(outputs), outputs, false));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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(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)
|
|
|
|
@ -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(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));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|