Skip to content

Commit 04af0ba

Browse files
sipasipa
committed
Replace ge_equals_ge[,j] calls with group.h equality calls
1 parent 60525f6 commit 04af0ba

File tree

5 files changed

+45
-55
lines changed

5 files changed

+45
-55
lines changed

‎src/modules/ellswift/tests_exhaustive_impl.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ static void test_exhaustive_ellswift(const secp256k1_context *ctx, const secp256
3232
/* Decode ellswift pubkey and check that it matches the precomputed group element. */
3333
secp256k1_ellswift_decode(ctx, &pub_decoded, ell64);
3434
secp256k1_pubkey_load(ctx, &ge_decoded, &pub_decoded);
35-
ge_equals_ge(&ge_decoded, &group[i]);
35+
CHECK(secp256k1_ge_eq_var(&ge_decoded, &group[i]));
3636
}
3737
}
3838

‎src/modules/ellswift/tests_impl.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -237,7 +237,7 @@ void run_ellswift_tests(void) {
237237
secp256k1_ellswift_decode(CTX, &pubkey2, ell64);
238238
secp256k1_pubkey_load(CTX, &g2, &pubkey2);
239239
/* Compare with original. */
240-
ge_equals_ge(&g, &g2);
240+
CHECK(secp256k1_ge_eq_var(&g, &g2));
241241
}
242242
/* Verify the behavior of secp256k1_ellswift_create */
243243
for (i = 0; i < 400 * COUNT; i++) {
@@ -259,7 +259,7 @@ void run_ellswift_tests(void) {
259259
secp256k1_ellswift_decode(CTX, &pub, ell64);
260260
secp256k1_pubkey_load(CTX, &dec, &pub);
261261
secp256k1_ecmult(&res, NULL, &secp256k1_scalar_zero, &sec);
262-
ge_equals_gej(&dec, &res);
262+
CHECK(secp256k1_gej_eq_ge_var(&res, &dec));
263263
}
264264
/* Verify that secp256k1_ellswift_xdh computes the right shared X coordinate. */
265265
for (i = 0; i < 800 * COUNT; i++) {

‎src/tests.c‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -3770,7 +3770,7 @@ static void test_ge(void) {
37703770

37713771
/* Test gej + ge with Z ratio result (var). */
37723772
secp256k1_gej_add_ge_var(&resj, &gej[i1], &ge[i2], secp256k1_gej_is_infinity(&gej[i1]) ? NULL : &zr);
3773-
ge_equals_gej(&ref, &resj);
3773+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
37743774
if (!secp256k1_gej_is_infinity(&gej[i1]) && !secp256k1_gej_is_infinity(&resj)) {
37753775
secp256k1_fe zrz; secp256k1_fe_mul(&zrz, &zr, &gej[i1].z);
37763776
CHECK(secp256k1_fe_equal(&zrz, &resj.z));
@@ -3784,31 +3784,31 @@ static void test_ge(void) {
37843784
random_ge_x_magnitude(&ge2_zfi);
37853785
random_ge_y_magnitude(&ge2_zfi);
37863786
secp256k1_gej_add_zinv_var(&resj, &gej[i1], &ge2_zfi, &zf);
3787-
ge_equals_gej(&ref, &resj);
3787+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
37883788
}
37893789

37903790
/* Test gej + ge (const). */
37913791
if (i2 != 0) {
37923792
/* secp256k1_gej_add_ge does not support its second argument being infinity. */
37933793
secp256k1_gej_add_ge(&resj, &gej[i1], &ge[i2]);
3794-
ge_equals_gej(&ref, &resj);
3794+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
37953795
}
37963796

37973797
/* Test doubling (var). */
37983798
if ((i1 == 0 && i2 == 0) || ((i1 + 3)/4 == (i2 + 3)/4 && ((i1 + 3)%4)/2 == ((i2 + 3)%4)/2)) {
37993799
secp256k1_fe zr2;
38003800
/* Normal doubling with Z ratio result. */
38013801
secp256k1_gej_double_var(&resj, &gej[i1], &zr2);
3802-
ge_equals_gej(&ref, &resj);
3802+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
38033803
/* Check Z ratio. */
38043804
secp256k1_fe_mul(&zr2, &zr2, &gej[i1].z);
38053805
CHECK(secp256k1_fe_equal(&zr2, &resj.z));
38063806
/* Normal doubling. */
38073807
secp256k1_gej_double_var(&resj, &gej[i2], NULL);
3808-
ge_equals_gej(&ref, &resj);
3808+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
38093809
/* Constant-time doubling. */
38103810
secp256k1_gej_double(&resj, &gej[i2]);
3811-
ge_equals_gej(&ref, &resj);
3811+
CHECK(secp256k1_gej_eq_ge_var(&resj, &ref));
38123812
}
38133813

38143814
/* Test adding opposites. */
@@ -3820,12 +3820,12 @@ static void test_ge(void) {
38203820
if (i1 == 0) {
38213821
CHECK(secp256k1_ge_is_infinity(&ge[i1]));
38223822
CHECK(secp256k1_gej_is_infinity(&gej[i1]));
3823-
ge_equals_gej(&ref, &gej[i2]);
3823+
CHECK(secp256k1_gej_eq_ge_var(&gej[i2], &ref));
38243824
}
38253825
if (i2 == 0) {
38263826
CHECK(secp256k1_ge_is_infinity(&ge[i2]));
38273827
CHECK(secp256k1_gej_is_infinity(&gej[i2]));
3828-
ge_equals_gej(&ref, &gej[i1]);
3828+
CHECK(secp256k1_gej_eq_ge_var(&gej[i1], &ref));
38293829
}
38303830
}
38313831
}
@@ -3860,7 +3860,7 @@ static void test_ge(void) {
38603860
secp256k1_fe s;
38613861
random_fe_non_zero(&s);
38623862
secp256k1_gej_rescale(&gej[i], &s);
3863-
ge_equals_gej(&ge_set_all[i], &gej[i]);
3863+
CHECK(secp256k1_gej_eq_ge_var(&gej[i], &ge_set_all[i]));
38643864
}
38653865
free(ge_set_all);
38663866
}
@@ -3904,7 +3904,7 @@ static void test_ge(void) {
39043904
secp256k1_ge_set_all_gej_var(ge, gej, 4 * runs + 1);
39053905
/* check result */
39063906
for (i = 0; i < 4 * runs + 1; i++) {
3907-
ge_equals_gej(&ge[i], &gej[i]);
3907+
CHECK(secp256k1_gej_eq_ge_var(&gej[i], &ge[i]));
39083908
}
39093909

39103910
/* Test batch gej -> ge conversion with all infinities. */
@@ -4003,15 +4003,15 @@ static void test_add_neg_y_diff_x(void) {
40034003

40044004
secp256k1_gej_add_var(&resj, &aj, &bj, NULL);
40054005
secp256k1_ge_set_gej(&res, &resj);
4006-
ge_equals_gej(&res, &sumj);
4006+
CHECK(secp256k1_gej_eq_ge_var(&sumj, &res));
40074007

40084008
secp256k1_gej_add_ge(&resj, &aj, &b);
40094009
secp256k1_ge_set_gej(&res, &resj);
4010-
ge_equals_gej(&res, &sumj);
4010+
CHECK(secp256k1_gej_eq_ge_var(&sumj, &res));
40114011

40124012
secp256k1_gej_add_ge_var(&resj, &aj, &b, NULL);
40134013
secp256k1_ge_set_gej(&res, &resj);
4014-
ge_equals_gej(&res, &sumj);
4014+
CHECK(secp256k1_gej_eq_ge_var(&sumj, &res));
40154015
}
40164016

40174017
static void run_ge(void) {
@@ -4304,10 +4304,10 @@ static void test_point_times_order(const secp256k1_gej *point) {
43044304
CHECK(secp256k1_ge_is_infinity(&res3));
43054305
secp256k1_ecmult(&res1, point, &secp256k1_scalar_one, &secp256k1_scalar_zero);
43064306
secp256k1_ge_set_gej(&res3, &res1);
4307-
ge_equals_gej(&res3, point);
4307+
CHECK(secp256k1_gej_eq_ge_var(point, &res3));
43084308
secp256k1_ecmult(&res1, point, &secp256k1_scalar_zero, &secp256k1_scalar_one);
43094309
secp256k1_ge_set_gej(&res3, &res1);
4310-
ge_equals_ge(&res3, &secp256k1_ge_const_g);
4310+
CHECK(secp256k1_ge_eq_var(&secp256k1_ge_const_g, &res3));
43114311
}
43124312

43134313
/* These scalars reach large (in absolute value) outputs when fed to secp256k1_scalar_split_lambda.
@@ -4435,7 +4435,7 @@ static void ecmult_const_random_mult(void) {
44354435
secp256k1_ecmult_const(&b, &a, &xn);
44364436

44374437
CHECK(secp256k1_ge_is_valid_var(&a));
4438-
ge_equals_gej(&expected_b, &b);
4438+
CHECK(secp256k1_gej_eq_ge_var(&b, &expected_b));
44394439
}
44404440

44414441
static void ecmult_const_commutativity(void) {
@@ -4456,7 +4456,7 @@ static void ecmult_const_commutativity(void) {
44564456
secp256k1_ecmult_const(&res2, &mid2, &a);
44574457
secp256k1_ge_set_gej(&mid1, &res1);
44584458
secp256k1_ge_set_gej(&mid2, &res2);
4459-
ge_equals_ge(&mid1, &mid2);
4459+
CHECK(secp256k1_ge_eq_var(&mid1, &mid2));
44604460
}
44614461

44624462
static void ecmult_const_mult_zero_one(void) {
@@ -4483,13 +4483,13 @@ static void ecmult_const_mult_zero_one(void) {
44834483
/* 1*point */
44844484
secp256k1_ecmult_const(&res1, &point, &secp256k1_scalar_one);
44854485
secp256k1_ge_set_gej(&res2, &res1);
4486-
ge_equals_ge(&res2, &point);
4486+
CHECK(secp256k1_ge_eq_var(&res2, &point));
44874487

44884488
/* -1*point */
44894489
secp256k1_ecmult_const(&res1, &point, &negone);
44904490
secp256k1_gej_neg(&res1, &res1);
44914491
secp256k1_ge_set_gej(&res2, &res1);
4492-
ge_equals_ge(&res2, &point);
4492+
CHECK(secp256k1_ge_eq_var(&res2, &point));
44934493
}
44944494

44954495
static void ecmult_const_check_result(const secp256k1_ge *A, const secp256k1_scalar* q, const secp256k1_gej *res) {
@@ -4498,7 +4498,7 @@ static void ecmult_const_check_result(const secp256k1_ge *A, const secp256k1_sca
44984498
secp256k1_gej_set_ge(&pointj, A);
44994499
secp256k1_ecmult(&res2j, &pointj, q, &secp256k1_scalar_zero);
45004500
secp256k1_ge_set_gej(&res2, &res2j);
4501-
ge_equals_gej(&res2, res);
4501+
CHECK(secp256k1_gej_eq_ge_var(res, &res2));
45024502
}
45034503

45044504
static void ecmult_const_edges(void) {
@@ -4606,7 +4606,7 @@ static void ecmult_const_chain_multiply(void) {
46064606
secp256k1_ecmult_const(&point, &tmp, &scalar);
46074607
}
46084608
secp256k1_ge_set_gej(&res, &point);
4609-
ge_equals_gej(&res, &expected_point);
4609+
CHECK(secp256k1_gej_eq_ge_var(&expected_point, &res));
46104610
}
46114611

46124612
static void run_ecmult_const_tests(void) {
@@ -5414,11 +5414,11 @@ static void test_ecmult_accumulate(secp256k1_sha256* acc, const secp256k1_scalar
54145414
secp256k1_ecmult_multi_var(NULL, scratch, &rj5, &secp256k1_scalar_zero, test_ecmult_accumulate_cb, (void*)x, 1);
54155415
secp256k1_ecmult_const(&rj6, &secp256k1_ge_const_g, x);
54165416
secp256k1_ge_set_gej_var(&r, &rj1);
5417-
ge_equals_gej(&r, &rj2);
5418-
ge_equals_gej(&r, &rj3);
5419-
ge_equals_gej(&r, &rj4);
5420-
ge_equals_gej(&r, &rj5);
5421-
ge_equals_gej(&r, &rj6);
5417+
CHECK(secp256k1_gej_eq_ge_var(&rj2, &r));
5418+
CHECK(secp256k1_gej_eq_ge_var(&rj3, &r));
5419+
CHECK(secp256k1_gej_eq_ge_var(&rj4, &r));
5420+
CHECK(secp256k1_gej_eq_ge_var(&rj5, &r));
5421+
CHECK(secp256k1_gej_eq_ge_var(&rj6, &r));
54225422
if (secp256k1_ge_is_infinity(&r)) {
54235423
/* Store infinity as 0x00 */
54245424
const unsigned char zerobyte[1] = {0};
@@ -5572,7 +5572,7 @@ static void test_ecmult_gen_blind(void) {
55725572
CHECK(!gej_xyz_equals_gej(&pgej, &pgej2));
55735573
CHECK(!gej_xyz_equals_gej(&i, &CTX->ecmult_gen_ctx.initial));
55745574
secp256k1_ge_set_gej(&pge, &pgej);
5575-
ge_equals_gej(&pge, &pgej2);
5575+
CHECK(secp256k1_gej_eq_ge_var(&pgej2, &pge));
55765576
}
55775577

55785578
static void test_ecmult_gen_blind_reset(void) {
@@ -5963,7 +5963,7 @@ static void run_ec_pubkey_parse_test(void) {
59635963
SECP256K1_CHECKMEM_CHECK(&ge.x, sizeof(ge.x));
59645964
SECP256K1_CHECKMEM_CHECK(&ge.y, sizeof(ge.y));
59655965
SECP256K1_CHECKMEM_CHECK(&ge.infinity, sizeof(ge.infinity));
5966-
ge_equals_ge(&secp256k1_ge_const_g, &ge);
5966+
CHECK(secp256k1_ge_eq_var(&ge, &secp256k1_ge_const_g));
59675967
/* secp256k1_ec_pubkey_serialize illegal args. */
59685968
len = 65;
59695969
CHECK_ILLEGAL(CTX, secp256k1_ec_pubkey_serialize(CTX, NULL, &len, &pubkey, SECP256K1_EC_UNCOMPRESSED));
@@ -6532,7 +6532,7 @@ static void test_random_pubkeys(void) {
65326532
CHECK(secp256k1_eckey_pubkey_serialize(&elem, in, &size, 0));
65336533
CHECK(size == 65);
65346534
CHECK(secp256k1_eckey_pubkey_parse(&elem2, in, size));
6535-
ge_equals_ge(&elem,&elem2);
6535+
CHECK(secp256k1_ge_eq_var(&elem2, &elem));
65366536
/* Check that the X9.62 hybrid type is checked. */
65376537
in[0] = secp256k1_testrand_bits(1) ? 6 : 7;
65386538
res = secp256k1_eckey_pubkey_parse(&elem2, in, size);
@@ -6544,7 +6544,7 @@ static void test_random_pubkeys(void) {
65446544
}
65456545
}
65466546
if (res) {
6547-
ge_equals_ge(&elem,&elem2);
6547+
CHECK(secp256k1_ge_eq_var(&elem, &elem2));
65486548
CHECK(secp256k1_eckey_pubkey_serialize(&elem, out, &size, 0));
65496549
CHECK(secp256k1_memcmp_var(&in[1], &out[1], 64) == 0);
65506550
}

‎src/tests_exhaustive.c‎

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -67,7 +67,7 @@ static void test_exhaustive_endomorphism(const secp256k1_ge *group) {
6767
for (i = 0; i < EXHAUSTIVE_TEST_ORDER; i++) {
6868
secp256k1_ge res;
6969
secp256k1_ge_mul_lambda(&res, &group[i]);
70-
ge_equals_ge(&group[i * EXHAUSTIVE_TEST_LAMBDA % EXHAUSTIVE_TEST_ORDER], &res);
70+
CHECK(secp256k1_ge_eq_var(&group[i * EXHAUSTIVE_TEST_LAMBDA % EXHAUSTIVE_TEST_ORDER], &res));
7171
}
7272
}
7373

@@ -93,41 +93,41 @@ static void test_exhaustive_addition(const secp256k1_ge *group, const secp256k1_
9393
secp256k1_gej tmp;
9494
/* add_var */
9595
secp256k1_gej_add_var(&tmp, &groupj[i], &groupj[j], NULL);
96-
ge_equals_gej(&group[(i + j) % EXHAUSTIVE_TEST_ORDER], &tmp);
96+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i + j) % EXHAUSTIVE_TEST_ORDER]));
9797
/* add_ge */
9898
if (j > 0) {
9999
secp256k1_gej_add_ge(&tmp, &groupj[i], &group[j]);
100-
ge_equals_gej(&group[(i + j) % EXHAUSTIVE_TEST_ORDER], &tmp);
100+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i + j) % EXHAUSTIVE_TEST_ORDER]));
101101
}
102102
/* add_ge_var */
103103
secp256k1_gej_add_ge_var(&tmp, &groupj[i], &group[j], NULL);
104-
ge_equals_gej(&group[(i + j) % EXHAUSTIVE_TEST_ORDER], &tmp);
104+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i + j) % EXHAUSTIVE_TEST_ORDER]));
105105
/* add_zinv_var */
106106
zless_gej.infinity = groupj[j].infinity;
107107
zless_gej.x = groupj[j].x;
108108
zless_gej.y = groupj[j].y;
109109
secp256k1_gej_add_zinv_var(&tmp, &groupj[i], &zless_gej, &fe_inv);
110-
ge_equals_gej(&group[(i + j) % EXHAUSTIVE_TEST_ORDER], &tmp);
110+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i + j) % EXHAUSTIVE_TEST_ORDER]));
111111
}
112112
}
113113

114114
/* Check doubling */
115115
for (i = 0; i < EXHAUSTIVE_TEST_ORDER; i++) {
116116
secp256k1_gej tmp;
117117
secp256k1_gej_double(&tmp, &groupj[i]);
118-
ge_equals_gej(&group[(2 * i) % EXHAUSTIVE_TEST_ORDER], &tmp);
118+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(2 * i) % EXHAUSTIVE_TEST_ORDER]));
119119
secp256k1_gej_double_var(&tmp, &groupj[i], NULL);
120-
ge_equals_gej(&group[(2 * i) % EXHAUSTIVE_TEST_ORDER], &tmp);
120+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(2 * i) % EXHAUSTIVE_TEST_ORDER]));
121121
}
122122

123123
/* Check negation */
124124
for (i = 1; i < EXHAUSTIVE_TEST_ORDER; i++) {
125125
secp256k1_ge tmp;
126126
secp256k1_gej tmpj;
127127
secp256k1_ge_neg(&tmp, &group[i]);
128-
ge_equals_ge(&group[EXHAUSTIVE_TEST_ORDER - i], &tmp);
128+
CHECK(secp256k1_ge_eq_var(&tmp, &group[EXHAUSTIVE_TEST_ORDER - i]));
129129
secp256k1_gej_neg(&tmpj, &groupj[i]);
130-
ge_equals_gej(&group[EXHAUSTIVE_TEST_ORDER - i], &tmpj);
130+
CHECK(secp256k1_gej_eq_ge_var(&tmpj, &group[EXHAUSTIVE_TEST_ORDER - i]));
131131
}
132132
}
133133

@@ -144,8 +144,7 @@ static void test_exhaustive_ecmult(const secp256k1_ge *group, const secp256k1_ge
144144
secp256k1_scalar_set_int(&ng, j);
145145

146146
secp256k1_ecmult(&tmp, &groupj[r_log], &na, &ng);
147-
ge_equals_gej(&group[(i * r_log + j) % EXHAUSTIVE_TEST_ORDER], &tmp);
148-
147+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i * r_log + j) % EXHAUSTIVE_TEST_ORDER]));
149148
}
150149
}
151150
}
@@ -163,7 +162,7 @@ static void test_exhaustive_ecmult(const secp256k1_ge *group, const secp256k1_ge
163162

164163
/* Test secp256k1_ecmult_const. */
165164
secp256k1_ecmult_const(&tmp, &group[i], &ng);
166-
ge_equals_gej(&group[(i * j) % EXHAUSTIVE_TEST_ORDER], &tmp);
165+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i * j) % EXHAUSTIVE_TEST_ORDER]));
167166

168167
if (i != 0 && j != 0) {
169168
/* Test secp256k1_ecmult_const_xonly with all curve X coordinates, and xd=NULL. */
@@ -215,7 +214,7 @@ static void test_exhaustive_ecmult_multi(const secp256k1_context *ctx, const sec
215214
data.pt[1] = group[y];
216215

217216
secp256k1_ecmult_multi_var(&ctx->error_callback, scratch, &tmp, &g_sc, ecmult_multi_callback, &data, 2);
218-
ge_equals_gej(&group[(i * x + j * y + k) % EXHAUSTIVE_TEST_ORDER], &tmp);
217+
CHECK(secp256k1_gej_eq_ge_var(&tmp, &group[(i * x + j * y + k) % EXHAUSTIVE_TEST_ORDER]));
219218
}
220219
}
221220
}

‎src/testutil.h‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@
77
#define SECP256K1_TESTUTIL_H
88

99
#include "field.h"
10-
#include "group.h"
1110
#include "testrand.h"
1211
#include "util.h"
1312

@@ -27,12 +26,4 @@ static void random_fe_non_zero(secp256k1_fe *nz) {
2726
} while (secp256k1_fe_is_zero(nz));
2827
}
2928

30-
static void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
31-
CHECK(secp256k1_ge_eq_var(a, b));
32-
}
33-
34-
static void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
35-
CHECK(secp256k1_gej_eq_ge_var(b, a));
36-
}
37-
3829
#endif /* SECP256K1_TESTUTIL_H */

0 commit comments

Comments
 (0)