Skip to content

Commit debf3e5

Browse files
real-or-randomreal-or-random
committed
Merge bitcoin-core/secp256k1#1330: refactor: take use of secp256k1_scalar_{zero,one} constants
ade5b36 tests: add checks for scalar constants `secp256k1_scalar_{zero,one}` (Sebastian Falbesoner) 654246c refactor: take use of `secp256k1_scalar_{zero,one}` constants (Sebastian Falbesoner) Pull request description: Rather than allocating a (non-constant) scalar variable on the stack with the sole purpose of setting it to a constant value, the global constants `secp256k1_scalar_{zero,one}` (apparently introduced in 34a67c7, PR bitcoin#710) can be directly used instead for the values 0 or 1. There is very likely not even a difference in run-time, but it leads to simpler and less code which might be nice. ACKs for top commit: sipa: utACK ade5b36 real-or-random: utACK ade5b36 Tree-SHA512: 0ff05a449c153f7117a4a56efef04b2087c2330f4692f3390a0b1d95573785ac7ae3fe689ed0ec2ecc64b575d2489d6e341d32567e75a1a4b4d458c3ecd406a1
2 parents d75dc59 + ade5b36 commit debf3e5

File tree

4 files changed

+53
-62
lines changed

4 files changed

+53
-62
lines changed

‎src/bench_ecmult.c

+1-3
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

+2-6
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

+2-6
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

+48-47
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
}
@@ -2357,13 +2354,25 @@ static void run_scalar_tests(void) {
23572354
run_scalar_set_b32_seckey_tests();
23582355
}
23592356

2357+
{
2358+
/* Check that the scalar constants secp256k1_scalar_zero and
2359+
secp256k1_scalar_one contain the expected values. */
2360+
secp256k1_scalar zero, one;
2361+
2362+
CHECK(secp256k1_scalar_is_zero(&secp256k1_scalar_zero));
2363+
secp256k1_scalar_set_int(&zero, 0);
2364+
CHECK(secp256k1_scalar_eq(&zero, &secp256k1_scalar_zero));
2365+
2366+
CHECK(secp256k1_scalar_is_one(&secp256k1_scalar_one));
2367+
secp256k1_scalar_set_int(&one, 1);
2368+
CHECK(secp256k1_scalar_eq(&one, &secp256k1_scalar_one));
2369+
}
2370+
23602371
{
23612372
/* (-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);
2373+
secp256k1_scalar o;
2374+
secp256k1_scalar_negate(&o, &secp256k1_scalar_one);
2375+
secp256k1_scalar_add(&o, &o, &secp256k1_scalar_one);
23672376
CHECK(secp256k1_scalar_is_zero(&o));
23682377
secp256k1_scalar_negate(&o, &o);
23692378
CHECK(secp256k1_scalar_is_zero(&o));
@@ -2388,7 +2397,6 @@ static void run_scalar_tests(void) {
23882397
secp256k1_scalar y;
23892398
secp256k1_scalar z;
23902399
secp256k1_scalar zz;
2391-
secp256k1_scalar one;
23922400
secp256k1_scalar r1;
23932401
secp256k1_scalar r2;
23942402
secp256k1_scalar zzv;
@@ -2925,7 +2933,6 @@ static void run_scalar_tests(void) {
29252933
0x1e, 0x86, 0x5d, 0x89, 0x63, 0xe6, 0x0a, 0x46,
29262934
0x5c, 0x02, 0x97, 0x1b, 0x62, 0x43, 0x86, 0xf5}}
29272935
};
2928-
secp256k1_scalar_set_int(&one, 1);
29292936
for (i = 0; i < 33; i++) {
29302937
secp256k1_scalar_set_b32(&x, chal[i][0], &overflow);
29312938
CHECK(!overflow);
@@ -2948,7 +2955,7 @@ static void run_scalar_tests(void) {
29482955
CHECK(secp256k1_scalar_eq(&x, &z));
29492956
secp256k1_scalar_mul(&zz, &zz, &y);
29502957
CHECK(!secp256k1_scalar_check_overflow(&zz));
2951-
CHECK(secp256k1_scalar_eq(&one, &zz));
2958+
CHECK(secp256k1_scalar_eq(&secp256k1_scalar_one, &zz));
29522959
}
29532960
}
29542961
}
@@ -4646,7 +4653,6 @@ static int ecmult_multi_false_callback(secp256k1_scalar *sc, secp256k1_ge *pt, s
46464653

46474654
static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi_func ecmult_multi) {
46484655
int ncount;
4649-
secp256k1_scalar szero;
46504656
secp256k1_scalar sc[32];
46514657
secp256k1_ge pt[32];
46524658
secp256k1_gej r;
@@ -4655,7 +4661,6 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
46554661

46564662
data.sc = sc;
46574663
data.pt = pt;
4658-
secp256k1_scalar_set_int(&szero, 0);
46594664

46604665
/* No points to multiply */
46614666
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, NULL, ecmult_multi_callback, &data, 0));
@@ -4673,21 +4678,21 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
46734678
pt[1] = secp256k1_ge_const_g;
46744679

46754680
/* only G scalar */
4676-
secp256k1_ecmult(&r2, &ptgj, &szero, &sc[0]);
4681+
secp256k1_ecmult(&r2, &ptgj, &secp256k1_scalar_zero, &sc[0]);
46774682
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &sc[0], ecmult_multi_callback, &data, 0));
46784683
CHECK(secp256k1_gej_eq_var(&r, &r2));
46794684

46804685
/* 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));
4686+
secp256k1_ecmult(&r2, &ptgj, &sc[0], &secp256k1_scalar_zero);
4687+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 1));
46834688
CHECK(secp256k1_gej_eq_var(&r, &r2));
46844689

46854690
/* 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));
4691+
CHECK(!ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_false_callback, &data, 1));
46874692

46884693
/* 2-point */
46894694
secp256k1_ecmult(&r2, &ptgj, &sc[0], &sc[1]);
4690-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 2));
4695+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 2));
46914696
CHECK(secp256k1_gej_eq_var(&r, &r2));
46924697

46934698
/* 2-point with G scalar */
@@ -4707,7 +4712,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47074712
random_scalar_order(&sc[i]);
47084713
secp256k1_ge_set_infinity(&pt[i]);
47094714
}
4710-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4715+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47114716
CHECK(secp256k1_gej_is_infinity(&r));
47124717
}
47134718

@@ -4717,7 +4722,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47174722
pt[i] = ptg;
47184723
secp256k1_scalar_set_int(&sc[i], 0);
47194724
}
4720-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4725+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47214726
CHECK(secp256k1_gej_is_infinity(&r));
47224727
}
47234728

@@ -4730,7 +4735,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47304735
pt[2 * i + 1] = ptg;
47314736
}
47324737

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

47364741
random_scalar_order(&sc[0]);
@@ -4743,7 +4748,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47434748
secp256k1_ge_neg(&pt[2*i+1], &pt[2*i]);
47444749
}
47454750

4746-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, sizes[j]));
4751+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, sizes[j]));
47474752
CHECK(secp256k1_gej_is_infinity(&r));
47484753
}
47494754

@@ -4758,7 +4763,7 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47584763
secp256k1_scalar_negate(&sc[i], &sc[i]);
47594764
}
47604765

4761-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 32));
4766+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 32));
47624767
CHECK(secp256k1_gej_is_infinity(&r));
47634768
}
47644769

@@ -4776,8 +4781,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47764781
secp256k1_gej_add_ge_var(&r, &r, &pt[i], NULL);
47774782
}
47784783

4779-
secp256k1_ecmult(&r2, &r, &sc[0], &szero);
4780-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
4784+
secp256k1_ecmult(&r2, &r, &sc[0], &secp256k1_scalar_zero);
4785+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
47814786
CHECK(secp256k1_gej_eq_var(&r, &r2));
47824787
}
47834788

@@ -4797,8 +4802,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
47974802
}
47984803

47994804
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));
4805+
secp256k1_ecmult(&r2, &p0j, &rs, &secp256k1_scalar_zero);
4806+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
48024807
CHECK(secp256k1_gej_eq_var(&r, &r2));
48034808
}
48044809

@@ -4809,13 +4814,13 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48094814
}
48104815

48114816
secp256k1_scalar_clear(&sc[0]);
4812-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &szero, ecmult_multi_callback, &data, 20));
4817+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 20));
48134818
secp256k1_scalar_clear(&sc[1]);
48144819
secp256k1_scalar_clear(&sc[2]);
48154820
secp256k1_scalar_clear(&sc[3]);
48164821
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));
4822+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 6));
4823+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 5));
48194824
CHECK(secp256k1_gej_is_infinity(&r));
48204825

48214826
/* Run through s0*(t0*P) + s1*(t1*P) exhaustively for many small values of s0, s1, t0, t1 */
@@ -4839,8 +4844,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48394844
secp256k1_scalar_set_int(&t1, (t1i + 1) / 2);
48404845
secp256k1_scalar_cond_negate(&t1, t1i & 1);
48414846

4842-
secp256k1_ecmult(&t0p, &ptgj, &t0, &szero);
4843-
secp256k1_ecmult(&t1p, &ptgj, &t1, &szero);
4847+
secp256k1_ecmult(&t0p, &ptgj, &t0, &secp256k1_scalar_zero);
4848+
secp256k1_ecmult(&t1p, &ptgj, &t1, &secp256k1_scalar_zero);
48444849

48454850
for(s0i = 0; s0i < TOP; s0i++) {
48464851
for(s1i = 0; s1i < TOP; s1i++) {
@@ -4859,8 +4864,8 @@ static void test_ecmult_multi(secp256k1_scratch *scratch, secp256k1_ecmult_multi
48594864
secp256k1_scalar_mul(&tmp2, &t1, &sc[1]);
48604865
secp256k1_scalar_add(&tmp1, &tmp1, &tmp2);
48614866

4862-
secp256k1_ecmult(&expected, &ptgj, &tmp1, &szero);
4863-
CHECK(ecmult_multi(&CTX->error_callback, scratch, &actual, &szero, ecmult_multi_callback, &data, 2));
4867+
secp256k1_ecmult(&expected, &ptgj, &tmp1, &secp256k1_scalar_zero);
4868+
CHECK(ecmult_multi(&CTX->error_callback, scratch, &actual, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 2));
48644869
CHECK(secp256k1_gej_eq_var(&actual, &expected));
48654870
}
48664871
}
@@ -5036,7 +5041,6 @@ static int test_ecmult_multi_random(secp256k1_scratch *scratch) {
50365041
}
50375042

50385043
static void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_multi) {
5039-
secp256k1_scalar szero;
50405044
secp256k1_scalar sc;
50415045
secp256k1_ge pt;
50425046
secp256k1_gej r;
@@ -5047,11 +5051,10 @@ static void test_ecmult_multi_batch_single(secp256k1_ecmult_multi_func ecmult_mu
50475051
random_scalar_order(&sc);
50485052
data.sc = &sc;
50495053
data.pt = &pt;
5050-
secp256k1_scalar_set_int(&szero, 0);
50515054

50525055
/* Try to multiply 1 point, but scratch space is empty.*/
50535056
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));
5057+
CHECK(!ecmult_multi(&CTX->error_callback, scratch_empty, &r, &secp256k1_scalar_zero, ecmult_multi_callback, &data, 1));
50555058
secp256k1_scratch_destroy(&CTX->error_callback, scratch_empty);
50565059
}
50575060

@@ -5159,7 +5162,6 @@ static void test_ecmult_multi_batch_size_helper(void) {
51595162
static void test_ecmult_multi_batching(void) {
51605163
static const int n_points = 2*ECMULT_PIPPENGER_THRESHOLD;
51615164
secp256k1_scalar scG;
5162-
secp256k1_scalar szero;
51635165
secp256k1_scalar *sc = (secp256k1_scalar *)checked_malloc(&CTX->error_callback, sizeof(secp256k1_scalar) * n_points);
51645166
secp256k1_ge *pt = (secp256k1_ge *)checked_malloc(&CTX->error_callback, sizeof(secp256k1_ge) * n_points);
51655167
secp256k1_gej r;
@@ -5169,11 +5171,10 @@ static void test_ecmult_multi_batching(void) {
51695171
secp256k1_scratch *scratch;
51705172

51715173
secp256k1_gej_set_infinity(&r2);
5172-
secp256k1_scalar_set_int(&szero, 0);
51735174

51745175
/* Get random scalars and group elements and compute result */
51755176
random_scalar_order(&scG);
5176-
secp256k1_ecmult(&r2, &r2, &szero, &scG);
5177+
secp256k1_ecmult(&r2, &r2, &secp256k1_scalar_zero, &scG);
51775178
for(i = 0; i < n_points; i++) {
51785179
secp256k1_ge ptg;
51795180
secp256k1_gej ptgj;

0 commit comments

Comments
 (0)