Skip to content

Commit e11cdc3

Browse files
theStackdderjoel
theStack
authored and
dderjoel
committed
refactor: take use of secp256k1_scalar_{zero,one} constants
1 parent bf9169d commit e11cdc3

File tree

4 files changed

+39
-62
lines changed

4 files changed

+39
-62
lines changed

‎src/bench_ecmult.c

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -138,12 +138,10 @@ static void bench_ecmult_1p_teardown(void* arg, int iters) {
138138

139139
static void bench_ecmult_0p_g(void* arg, int iters) {
140140
bench_data* data = (bench_data*)arg;
141-
secp256k1_scalar zero;
142141
int i;
143142

144-
secp256k1_scalar_set_int(&zero, 0);
145143
for (i = 0; i < iters; ++i) {
146-
secp256k1_ecmult(&data->output[i], NULL, &zero, &data->scalars[(data->offset1+i) % POINTS]);
144+
secp256k1_ecmult(&data->output[i], NULL, &secp256k1_scalar_zero, &data->scalars[(data->offset1+i) % POINTS]);
147145
}
148146
}
149147

‎src/eckey_impl.h

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -59,10 +59,8 @@ static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, const secp25
5959

6060
static int secp256k1_eckey_pubkey_tweak_add(secp256k1_ge *key, const secp256k1_scalar *tweak) {
6161
secp256k1_gej pt;
62-
secp256k1_scalar one;
6362
secp256k1_gej_set_ge(&pt, key);
64-
secp256k1_scalar_set_int(&one, 1);
65-
secp256k1_ecmult(&pt, &pt, &one, tweak);
63+
secp256k1_ecmult(&pt, &pt, &secp256k1_scalar_one, tweak);
6664

6765
if (secp256k1_gej_is_infinity(&pt)) {
6866
return 0;
@@ -80,15 +78,13 @@ static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, const secp25
8078
}
8179

8280
static int secp256k1_eckey_pubkey_tweak_mul(secp256k1_ge *key, const secp256k1_scalar *tweak) {
83-
secp256k1_scalar zero;
8481
secp256k1_gej pt;
8582
if (secp256k1_scalar_is_zero(tweak)) {
8683
return 0;
8784
}
8885

89-
secp256k1_scalar_set_int(&zero, 0);
9086
secp256k1_gej_set_ge(&pt, key);
91-
secp256k1_ecmult(&pt, &pt, tweak, &zero);
87+
secp256k1_ecmult(&pt, &pt, tweak, &secp256k1_scalar_zero);
9288
secp256k1_ge_set_gej(key, &pt);
9389
return 1;
9490
}

‎src/ecmult_impl.h

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -770,14 +770,12 @@ static size_t secp256k1_pippenger_max_points(const secp256k1_callback* error_cal
770770
* require a scratch space */
771771
static int secp256k1_ecmult_multi_simple_var(secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n_points) {
772772
size_t point_idx;
773-
secp256k1_scalar szero;
774773
secp256k1_gej tmpj;
775774

776-
secp256k1_scalar_set_int(&szero, 0);
777775
secp256k1_gej_set_infinity(r);
778776
secp256k1_gej_set_infinity(&tmpj);
779777
/* r = inp_g_sc*G */
780-
secp256k1_ecmult(r, &tmpj, &szero, inp_g_sc);
778+
secp256k1_ecmult(r, &tmpj, &secp256k1_scalar_zero, inp_g_sc);
781779
for (point_idx = 0; point_idx < n_points; point_idx++) {
782780
secp256k1_ge point;
783781
secp256k1_gej pointj;
@@ -825,9 +823,7 @@ static int secp256k1_ecmult_multi_var(const secp256k1_callback* error_callback,
825823
if (inp_g_sc == NULL && n == 0) {
826824
return 1;
827825
} else if (n == 0) {
828-
secp256k1_scalar szero;
829-
secp256k1_scalar_set_int(&szero, 0);
830-
secp256k1_ecmult(r, r, &szero, inp_g_sc);
826+
secp256k1_ecmult(r, r, &secp256k1_scalar_zero, inp_g_sc);
831827
return 1;
832828
}
833829
if (scratch == NULL) {

‎src/tests.c

Lines changed: 34 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -2307,26 +2307,23 @@ static void scalar_test(void) {
23072307

23082308
{
23092309
/* Test multiplicative identity. */
2310-
secp256k1_scalar r1, v1;
2311-
secp256k1_scalar_set_int(&v1,1);
2312-
secp256k1_scalar_mul(&r1, &s1, &v1);
2310+
secp256k1_scalar r1;
2311+
secp256k1_scalar_mul(&r1, &s1, &secp256k1_scalar_one);
23132312
CHECK(secp256k1_scalar_eq(&r1, &s1));
23142313
}
23152314

23162315
{
23172316
/* Test additive identity. */
2318-
secp256k1_scalar r1, v0;
2319-
secp256k1_scalar_set_int(&v0,0);
2320-
secp256k1_scalar_add(&r1, &s1, &v0);
2317+
secp256k1_scalar r1;
2318+
secp256k1_scalar_add(&r1, &s1, &secp256k1_scalar_zero);
23212319
CHECK(secp256k1_scalar_eq(&r1, &s1));
23222320
}
23232321

23242322
{
23252323
/* Test zero product property. */
2326-
secp256k1_scalar r1, v0;
2327-
secp256k1_scalar_set_int(&v0,0);
2328-
secp256k1_scalar_mul(&r1, &s1, &v0);
2329-
CHECK(secp256k1_scalar_eq(&r1, &v0));
2324+
secp256k1_scalar r1;
2325+
secp256k1_scalar_mul(&r1, &s1, &secp256k1_scalar_zero);
2326+
CHECK(secp256k1_scalar_eq(&r1, &secp256k1_scalar_zero));
23302327
}
23312328

23322329
}
@@ -2359,11 +2356,9 @@ static void run_scalar_tests(void) {
23592356

23602357
{
23612358
/* (-1)+1 should be zero. */
2362-
secp256k1_scalar s, o;
2363-
secp256k1_scalar_set_int(&s, 1);
2364-
CHECK(secp256k1_scalar_is_one(&s));
2365-
secp256k1_scalar_negate(&o, &s);
2366-
secp256k1_scalar_add(&o, &o, &s);
2359+
secp256k1_scalar o;
2360+
secp256k1_scalar_negate(&o, &secp256k1_scalar_one);
2361+
secp256k1_scalar_add(&o, &o, &secp256k1_scalar_one);
23672362
CHECK(secp256k1_scalar_is_zero(&o));
23682363
secp256k1_scalar_negate(&o, &o);
23692364
CHECK(secp256k1_scalar_is_zero(&o));
@@ -2388,7 +2383,6 @@ static void run_scalar_tests(void) {
23882383
secp256k1_scalar y;
23892384
secp256k1_scalar z;
23902385
secp256k1_scalar zz;
2391-
secp256k1_scalar one;
23922386
secp256k1_scalar r1;
23932387
secp256k1_scalar r2;
23942388
secp256k1_scalar zzv;
@@ -2925,7 +2919,6 @@ static void run_scalar_tests(void) {
29252919
0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
29262920
0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5}}
29272921
};
2928-
secp256k1_scalar_set_int(&one, 1);
29292922
for (i = 0; i < 33; i++) {
29302923
secp256k1_scalar_set_b32(&x, chal[i][0], &overflow);
29312924
CHECK(!overflow);
@@ -2948,7 +2941,7 @@ static void run_scalar_tests(void) {
29482941
CHECK(secp256k1_scalar_eq(&x, &z));
29492942
secp256k1_scalar_mul(&zz, &zz, &y);
29502943
CHECK(!secp256k1_scalar_check_overflow(&zz));
2951-
CHECK(secp256k1_scalar_eq(&one, &zz));
2944+
CHECK(secp256k1_scalar_eq(&secp256k1_scalar_one, &zz));
29522945
}
29532946
}
29542947
}
@@ -4646,7 +4639,6 @@ static int ecmult_multi_false_callback(secp256k1_scalar *sc, secp256k1_ge *pt, s
46464639

46474640
static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi_func ecmult_multi) {
46484641
int ncount;
4649-
secp256k1_scalar szero;
46504642
secp256k1_scalar sc[32];
46514643
secp256k1_ge pt[32];
46524644
secp256k1_gej r;
@@ -4655,7 +4647,6 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
46554647

46564648
data.sc = sc;
46574649
data.pt = pt;
4658-
secp256k1_scalar_set_int(&szero, 0);
46594650

46604651
/* No points to multiply */
46614652
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, NULL, ecmult_multi_callback, &data, 0));
@@ -4673,21 +4664,21 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
46734664
pt[1] = secp256k1_ge_const_g;
46744665

46754666
/* only G scalar */
4676-
secp256k1_ecmult(&r2, &ptgj, &szero, &sc[0]);
4667+
secp256k1_ecmult(&r2, &ptgj, &secp256k1_scalar_zero, &sc[0]);
46774668
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &sc[0], ecmult_multi_callback, &data, 0));
46784669
CHECK(secp256k1_gej_eq_var(&r, &r2));
46794670

46804671
/* 1-point */
4681-
secp256k1_ecmult(&r2, &ptgj, &sc[0], &szero);
4682-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 1));
4672+
secp256k1_ecmult(&r2, &ptgj, &sc[0], &secp256k1_scalar_zero);
4673+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 1));
46834674
CHECK(secp256k1_gej_eq_var(&r, &r2));
46844675

46854676
/* Try to multiply 1 point, but callback returns false */
4686-
CHECK(!ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_false_callback, &data, 1));
4677+
CHECK(!ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_false_callback, &data, 1));
46874678

46884679
/* 2-point */
46894680
secp256k1_ecmult(&r2, &ptgj, &sc[0], &sc[1]);
4690-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 2));
4681+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 2));
46914682
CHECK(secp256k1_gej_eq_var(&r, &r2));
46924683

46934684
/* 2-point with G scalar */
@@ -4707,7 +4698,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47074698
random_scalar_order(&sc[i]);
47084699
secp256k1_ge_set_infinity(&pt[i]);
47094700
}
4710-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4701+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47114702
CHECK(secp256k1_gej_is_infinity(&r));
47124703
}
47134704

@@ -4717,7 +4708,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47174708
pt[i] = ptg;
47184709
secp256k1_scalar_set_int(&sc[i], 0);
47194710
}
4720-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4711+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47214712
CHECK(secp256k1_gej_is_infinity(&r));
47224713
}
47234714

@@ -4730,7 +4721,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47304721
pt[2 * i + 1] = ptg;
47314722
}
47324723

4733-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4724+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47344725
CHECK(secp256k1_gej_is_infinity(&r));
47354726

47364727
random_scalar_order(&sc[0]);
@@ -4743,7 +4734,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47434734
secp256k1_ge_neg(&pt[2*i+1], &pt[2*i]);
47444735
}
47454736

4746-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4737+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47474738
CHECK(secp256k1_gej_is_infinity(&r));
47484739
}
47494740

@@ -4758,7 +4749,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47584749
secp256k1_scalar_negate(&sc[i], &sc[i]);
47594750
}
47604751

4761-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 32));
4752+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 32));
47624753
CHECK(secp256k1_gej_is_infinity(&r));
47634754
}
47644755

@@ -4776,8 +4767,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47764767
secp256k1_gej_add_ge_var(&r, &r, &pt[i], NULL);
47774768
}
47784769

4779-
secp256k1_ecmult(&r2, &r, &sc[0], &szero);
4780-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
4770+
secp256k1_ecmult(&r2, &r, &sc[0], &secp256k1_scalar_zero);
4771+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
47814772
CHECK(secp256k1_gej_eq_var(&r, &r2));
47824773
}
47834774

@@ -4797,8 +4788,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47974788
}
47984789

47994790
secp256k1_gej_set_ge(&p0j, &pt[0]);
4800-
secp256k1_ecmult(&r2, &p0j, &rs, &szero);
4801-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
4791+
secp256k1_ecmult(&r2, &p0j, &rs, &secp256k1_scalar_zero);
4792+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
48024793
CHECK(secp256k1_gej_eq_var(&r, &r2));
48034794
}
48044795

@@ -4809,13 +4800,13 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48094800
}
48104801

48114802
secp256k1_scalar_clear(&sc[0]);
4812-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
4803+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
48134804
secp256k1_scalar_clear(&sc[1]);
48144805
secp256k1_scalar_clear(&sc[2]);
48154806
secp256k1_scalar_clear(&sc[3]);
48164807
secp256k1_scalar_clear(&sc[4]);
4817-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 6));
4818-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 5));
4808+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 6));
4809+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 5));
48194810
CHECK(secp256k1_gej_is_infinity(&r));
48204811

48214812
/* Run through s0*(t0*P) + s1*(t1*P) exhaustively for many small values of s0, s1, t0, t1 */
@@ -4839,8 +4830,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48394830
secp256k1_scalar_set_int(&t1, (t1i + 1) / 2);
48404831
secp256k1_scalar_cond_negate(&t1, t1i & 1);
48414832

4842-
secp256k1_ecmult(&t0p, &ptgj, &t0, &szero);
4843-
secp256k1_ecmult(&t1p, &ptgj, &t1, &szero);
4833+
secp256k1_ecmult(&t0p, &ptgj, &t0, &secp256k1_scalar_zero);
4834+
secp256k1_ecmult(&t1p, &ptgj, &t1, &secp256k1_scalar_zero);
48444835

48454836
for(s0i = 0; s0i < TOP; s0i++) {
48464837
for(s1i = 0; s1i < TOP; s1i++) {
@@ -4859,8 +4850,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48594850
secp256k1_scalar_mul(&tmp2, &t1, &sc[1]);
48604851
secp256k1_scalar_add(&tmp1, &tmp1, &tmp2);
48614852

4862-
secp256k1_ecmult(&expected, &ptgj, &tmp1, &szero);
4863-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &actual, &szero, ecmult_multi_callback, &data, 2));
4853+
secp256k1_ecmult(&expected, &ptgj, &tmp1, &secp256k1_scalar_zero);
4854+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &actual, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 2));
48644855
CHECK(secp256k1_gej_eq_var(&actual, &expected));
48654856
}
48664857
}
@@ -5036,7 +5027,6 @@ static int test_ecmult_multi_random(secp256k1_scratch *scratch) {
50365027
}
50375028

50385029
static void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_multi) {
5039-
secp256k1_scalar szero;
50405030
secp256k1_scalar sc;
50415031
secp256k1_ge pt;
50425032
secp256k1_gej r;
@@ -5047,11 +5037,10 @@ static void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_mu
50475037
random_scalar_order(&sc);
50485038
data.sc = &sc;
50495039
data.pt = &pt;
5050-
secp256k1_scalar_set_int(&szero, 0);
50515040

50525041
/* Try to multiply 1 point, but scratch space is empty.*/
50535042
scratch_empty = secp256k1_scratch_create(&CTX->error_callback, 0);
5054-
CHECK(!ecmult_multi(&CTX->error_callback, scratch_empty, &r, &szero, ecmult_multi_callback, &data, 1));
5043+
CHECK(!ecmult_multi(&CTX->error_callback, scratch_empty, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 1));
50555044
secp256k1_scratch_destroy(&CTX->error_callback, scratch_empty);
50565045
}
50575046

@@ -5159,7 +5148,6 @@ static void test_ecmult_multi_batch_size_helper(void) {
51595148
static void test_ecmult_multi_batching(void) {
51605149
static const int n_points = 2*ECMULT_PIPPENGER_THRESHOLD;
51615150
secp256k1_scalar scG;
5162-
secp256k1_scalar szero;
51635151
secp256k1_scalar *sc = (secp256k1_scalar *)checked_malloc(&CTX->error_callback, sizeof(secp256k1_scalar) * n_points);
51645152
secp256k1_ge *pt = (secp256k1_ge *)checked_malloc(&CTX->error_callback, sizeof(secp256k1_ge) * n_points);
51655153
secp256k1_gej r;
@@ -5169,11 +5157,10 @@ static void test_ecmult_multi_batching(void) {
51695157
secp256k1_scratch *scratch;
51705158

51715159
secp256k1_gej_set_infinity(&r2);
5172-
secp256k1_scalar_set_int(&szero, 0);
51735160

51745161
/* Get random scalars and group elements and compute result */
51755162
random_scalar_order(&scG);
5176-
secp256k1_ecmult(&r2, &r2, &szero, &scG);
5163+
secp256k1_ecmult(&r2, &r2, &secp256k1_scalar_zero, &scG);
51775164
for(i = 0; i < n_points; i++) {
51785165
secp256k1_ge ptg;
51795166
secp256k1_gej ptgj;

0 commit comments

Comments
 (0)