Skip to content

Commit cf25c86

Browse files
theStacktheStack
committed
introduce and use SECP256K1_{FE,GE,GEJ}_VERIFY macros
By providing an uppercase variant of these verification functions, it is better visible that it is test code and surrounding `#ifdef VERIFY` blocks can be removed (if there is no other code around that could remain in production mode), as they don't serve their purpose any more. At some places intentional blank lines are inserted for grouping and better readadbility.
1 parent 5d89bc0 commit cf25c86

File tree

5 files changed

+184
-146
lines changed

5 files changed

+184
-146
lines changed

‎src/field.h

+2
Original file line numberDiff line numberDiff line change
@@ -345,8 +345,10 @@ static int secp256k1_fe_is_square_var(const secp256k1_fe *a);
345345

346346
/** Check invariants on a field element (no-op unless VERIFY is enabled). */
347347
static void secp256k1_fe_verify(const secp256k1_fe *a);
348+
#define SECP256K1_FE_VERIFY(a) secp256k1_fe_verify(a)
348349

349350
/** Check that magnitude of a is at most m (no-op unless VERIFY is enabled). */
350351
static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m);
352+
#define SECP256K1_FE_VERIFY_MAGNITUDE(a, m) secp256k1_fe_verify_magnitude(a, m)
351353

352354
#endif /* SECP256K1_FIELD_H */

‎src/field_impl.h

+99-61
Original file line numberDiff line numberDiff line change
@@ -20,12 +20,11 @@
2020

2121
SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
2222
secp256k1_fe na;
23-
#ifdef VERIFY
24-
secp256k1_fe_verify(a);
25-
secp256k1_fe_verify(b);
26-
secp256k1_fe_verify_magnitude(a, 1);
27-
secp256k1_fe_verify_magnitude(b, 31);
28-
#endif
23+
SECP256K1_FE_VERIFY(a);
24+
SECP256K1_FE_VERIFY(b);
25+
SECP256K1_FE_VERIFY_MAGNITUDE(a, 1);
26+
SECP256K1_FE_VERIFY_MAGNITUDE(b, 31);
27+
2928
secp256k1_fe_negate(&na, a, 1);
3029
secp256k1_fe_add(&na, b);
3130
return secp256k1_fe_normalizes_to_zero(&na);
@@ -44,11 +43,9 @@ static int secp256k1_fe_sqrt(secp256k1_fe * SECP256K1_RESTRICT r, const secp256k
4443
secp256k1_fe x2, x3, x6, x9, x11, x22, x44, x88, x176, x220, x223, t1;
4544
int j, ret;
4645

47-
#ifdef VERIFY
4846
VERIFY_CHECK(r != a);
49-
secp256k1_fe_verify(a);
50-
secp256k1_fe_verify_magnitude(a, 8);
51-
#endif
47+
SECP256K1_FE_VERIFY(a);
48+
SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
5249

5350
/** The binary representation of (p + 1)/4 has 3 blocks of 1s, with lengths in
5451
* { 2, 22, 223 }. Use an addition chain to calculate 2^n - 1 for each block:
@@ -151,11 +148,11 @@ static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m) { (void)
151148
static void secp256k1_fe_impl_verify(const secp256k1_fe *a);
152149
static void secp256k1_fe_verify(const secp256k1_fe *a) {
153150
/* Magnitude between 0 and 32. */
154-
secp256k1_fe_verify_magnitude(a, 32);
151+
SECP256K1_FE_VERIFY_MAGNITUDE(a, 32);
155152
/* Normalized is 0 or 1. */
156153
VERIFY_CHECK((a->normalized == 0) || (a->normalized == 1));
157154
/* If normalized, magnitude must be 0 or 1. */
158-
if (a->normalized) secp256k1_fe_verify_magnitude(a, 1);
155+
if (a->normalized) SECP256K1_FE_VERIFY_MAGNITUDE(a, 1);
159156
/* Invoke implementation-specific checks. */
160157
secp256k1_fe_impl_verify(a);
161158
}
@@ -168,89 +165,105 @@ static void secp256k1_fe_verify_magnitude(const secp256k1_fe *a, int m) {
168165

169166
static void secp256k1_fe_impl_normalize(secp256k1_fe *r);
170167
SECP256K1_INLINE static void secp256k1_fe_normalize(secp256k1_fe *r) {
171-
secp256k1_fe_verify(r);
168+
SECP256K1_FE_VERIFY(r);
169+
172170
secp256k1_fe_impl_normalize(r);
173171
r->magnitude = 1;
174172
r->normalized = 1;
175-
secp256k1_fe_verify(r);
173+
174+
SECP256K1_FE_VERIFY(r);
176175
}
177176

178177
static void secp256k1_fe_impl_normalize_weak(secp256k1_fe *r);
179178
SECP256K1_INLINE static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
180-
secp256k1_fe_verify(r);
179+
SECP256K1_FE_VERIFY(r);
180+
181181
secp256k1_fe_impl_normalize_weak(r);
182182
r->magnitude = 1;
183-
secp256k1_fe_verify(r);
183+
184+
SECP256K1_FE_VERIFY(r);
184185
}
185186

186187
static void secp256k1_fe_impl_normalize_var(secp256k1_fe *r);
187188
SECP256K1_INLINE static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
188-
secp256k1_fe_verify(r);
189+
SECP256K1_FE_VERIFY(r);
190+
189191
secp256k1_fe_impl_normalize_var(r);
190192
r->magnitude = 1;
191193
r->normalized = 1;
192-
secp256k1_fe_verify(r);
194+
195+
SECP256K1_FE_VERIFY(r);
193196
}
194197

195198
static int secp256k1_fe_impl_normalizes_to_zero(const secp256k1_fe *r);
196199
SECP256K1_INLINE static int secp256k1_fe_normalizes_to_zero(const secp256k1_fe *r) {
197-
secp256k1_fe_verify(r);
200+
SECP256K1_FE_VERIFY(r);
201+
198202
return secp256k1_fe_impl_normalizes_to_zero(r);
199203
}
200204

201205
static int secp256k1_fe_impl_normalizes_to_zero_var(const secp256k1_fe *r);
202206
SECP256K1_INLINE static int secp256k1_fe_normalizes_to_zero_var(const secp256k1_fe *r) {
203-
secp256k1_fe_verify(r);
207+
SECP256K1_FE_VERIFY(r);
208+
204209
return secp256k1_fe_impl_normalizes_to_zero_var(r);
205210
}
206211

207212
static void secp256k1_fe_impl_set_int(secp256k1_fe *r, int a);
208213
SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
209214
VERIFY_CHECK(0 <= a && a <= 0x7FFF);
215+
210216
secp256k1_fe_impl_set_int(r, a);
211217
r->magnitude = (a != 0);
212218
r->normalized = 1;
213-
secp256k1_fe_verify(r);
219+
220+
SECP256K1_FE_VERIFY(r);
214221
}
215222

216223
static void secp256k1_fe_impl_add_int(secp256k1_fe *r, int a);
217224
SECP256K1_INLINE static void secp256k1_fe_add_int(secp256k1_fe *r, int a) {
218225
VERIFY_CHECK(0 <= a && a <= 0x7FFF);
219-
secp256k1_fe_verify(r);
226+
SECP256K1_FE_VERIFY(r);
227+
220228
secp256k1_fe_impl_add_int(r, a);
221229
r->magnitude += 1;
222230
r->normalized = 0;
223-
secp256k1_fe_verify(r);
231+
232+
SECP256K1_FE_VERIFY(r);
224233
}
225234

226235
static void secp256k1_fe_impl_clear(secp256k1_fe *a);
227236
SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
228237
a->magnitude = 0;
229238
a->normalized = 1;
230239
secp256k1_fe_impl_clear(a);
231-
secp256k1_fe_verify(a);
240+
241+
SECP256K1_FE_VERIFY(a);
232242
}
233243

234244
static int secp256k1_fe_impl_is_zero(const secp256k1_fe *a);
235245
SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
236-
secp256k1_fe_verify(a);
246+
SECP256K1_FE_VERIFY(a);
237247
VERIFY_CHECK(a->normalized);
248+
238249
return secp256k1_fe_impl_is_zero(a);
239250
}
240251

241252
static int secp256k1_fe_impl_is_odd(const secp256k1_fe *a);
242253
SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
243-
secp256k1_fe_verify(a);
254+
SECP256K1_FE_VERIFY(a);
244255
VERIFY_CHECK(a->normalized);
256+
245257
return secp256k1_fe_impl_is_odd(a);
246258
}
247259

248260
static int secp256k1_fe_impl_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b);
249261
SECP256K1_INLINE static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
250-
secp256k1_fe_verify(a);
251-
secp256k1_fe_verify(b);
262+
SECP256K1_FE_VERIFY(a);
263+
SECP256K1_FE_VERIFY(b);
252264
VERIFY_CHECK(a->normalized);
253265
VERIFY_CHECK(b->normalized);
266+
254267
return secp256k1_fe_impl_cmp_var(a, b);
255268
}
256269

@@ -259,15 +272,16 @@ SECP256K1_INLINE static void secp256k1_fe_set_b32_mod(secp256k1_fe *r, const uns
259272
secp256k1_fe_impl_set_b32_mod(r, a);
260273
r->magnitude = 1;
261274
r->normalized = 0;
262-
secp256k1_fe_verify(r);
275+
276+
SECP256K1_FE_VERIFY(r);
263277
}
264278

265279
static int secp256k1_fe_impl_set_b32_limit(secp256k1_fe *r, const unsigned char *a);
266280
SECP256K1_INLINE static int secp256k1_fe_set_b32_limit(secp256k1_fe *r, const unsigned char *a) {
267281
if (secp256k1_fe_impl_set_b32_limit(r, a)) {
268282
r->magnitude = 1;
269283
r->normalized = 1;
270-
secp256k1_fe_verify(r);
284+
SECP256K1_FE_VERIFY(r);
271285
return 1;
272286
} else {
273287
/* Mark the output field element as invalid. */
@@ -278,83 +292,97 @@ SECP256K1_INLINE static int secp256k1_fe_set_b32_limit(secp256k1_fe *r, const un
278292

279293
static void secp256k1_fe_impl_get_b32(unsigned char *r, const secp256k1_fe *a);
280294
SECP256K1_INLINE static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
281-
secp256k1_fe_verify(a);
295+
SECP256K1_FE_VERIFY(a);
282296
VERIFY_CHECK(a->normalized);
297+
283298
secp256k1_fe_impl_get_b32(r, a);
284299
}
285300

286301
static void secp256k1_fe_impl_negate_unchecked(secp256k1_fe *r, const secp256k1_fe *a, int m);
287302
SECP256K1_INLINE static void secp256k1_fe_negate_unchecked(secp256k1_fe *r, const secp256k1_fe *a, int m) {
288-
secp256k1_fe_verify(a);
303+
SECP256K1_FE_VERIFY(a);
289304
VERIFY_CHECK(m >= 0 && m <= 31);
290-
secp256k1_fe_verify_magnitude(a, m);
305+
SECP256K1_FE_VERIFY_MAGNITUDE(a, m);
306+
291307
secp256k1_fe_impl_negate_unchecked(r, a, m);
292308
r->magnitude = m + 1;
293309
r->normalized = 0;
294-
secp256k1_fe_verify(r);
310+
311+
SECP256K1_FE_VERIFY(r);
295312
}
296313

297314
static void secp256k1_fe_impl_mul_int_unchecked(secp256k1_fe *r, int a);
298315
SECP256K1_INLINE static void secp256k1_fe_mul_int_unchecked(secp256k1_fe *r, int a) {
299-
secp256k1_fe_verify(r);
316+
SECP256K1_FE_VERIFY(r);
317+
300318
VERIFY_CHECK(a >= 0 && a <= 32);
301319
VERIFY_CHECK(a*r->magnitude <= 32);
302320
secp256k1_fe_impl_mul_int_unchecked(r, a);
303321
r->magnitude *= a;
304322
r->normalized = 0;
305-
secp256k1_fe_verify(r);
323+
324+
SECP256K1_FE_VERIFY(r);
306325
}
307326

308327
static void secp256k1_fe_impl_add(secp256k1_fe *r, const secp256k1_fe *a);
309328
SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
310-
secp256k1_fe_verify(r);
311-
secp256k1_fe_verify(a);
329+
SECP256K1_FE_VERIFY(r);
330+
SECP256K1_FE_VERIFY(a);
312331
VERIFY_CHECK(r->magnitude + a->magnitude <= 32);
332+
313333
secp256k1_fe_impl_add(r, a);
314334
r->magnitude += a->magnitude;
315335
r->normalized = 0;
316-
secp256k1_fe_verify(r);
336+
337+
SECP256K1_FE_VERIFY(r);
317338
}
318339

319340
static void secp256k1_fe_impl_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b);
320341
SECP256K1_INLINE static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
321-
secp256k1_fe_verify(a);
322-
secp256k1_fe_verify(b);
323-
secp256k1_fe_verify_magnitude(a, 8);
324-
secp256k1_fe_verify_magnitude(b, 8);
342+
SECP256K1_FE_VERIFY(a);
343+
SECP256K1_FE_VERIFY(b);
344+
SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
345+
SECP256K1_FE_VERIFY_MAGNITUDE(b, 8);
325346
VERIFY_CHECK(r != b);
326347
VERIFY_CHECK(a != b);
348+
327349
secp256k1_fe_impl_mul(r, a, b);
328350
r->magnitude = 1;
329351
r->normalized = 0;
330-
secp256k1_fe_verify(r);
352+
353+
SECP256K1_FE_VERIFY(r);
331354
}
332355

333356
static void secp256k1_fe_impl_sqr(secp256k1_fe *r, const secp256k1_fe *a);
334357
SECP256K1_INLINE static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
335-
secp256k1_fe_verify(a);
336-
secp256k1_fe_verify_magnitude(a, 8);
358+
SECP256K1_FE_VERIFY(a);
359+
SECP256K1_FE_VERIFY_MAGNITUDE(a, 8);
360+
337361
secp256k1_fe_impl_sqr(r, a);
338362
r->magnitude = 1;
339363
r->normalized = 0;
340-
secp256k1_fe_verify(r);
364+
365+
SECP256K1_FE_VERIFY(r);
341366
}
342367

343368
static void secp256k1_fe_impl_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag);
344369
SECP256K1_INLINE static void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
345370
VERIFY_CHECK(flag == 0 || flag == 1);
346-
secp256k1_fe_verify(a);
347-
secp256k1_fe_verify(r);
371+
SECP256K1_FE_VERIFY(a);
372+
SECP256K1_FE_VERIFY(r);
373+
348374
secp256k1_fe_impl_cmov(r, a, flag);
349375
if (a->magnitude > r->magnitude) r->magnitude = a->magnitude;
350376
if (!a->normalized) r->normalized = 0;
351-
secp256k1_fe_verify(r);
377+
378+
SECP256K1_FE_VERIFY(r);
352379
}
353380

354381
static void secp256k1_fe_impl_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a);
355382
SECP256K1_INLINE static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
356-
secp256k1_fe_verify(a);
383+
SECP256K1_FE_VERIFY(a);
357384
VERIFY_CHECK(a->normalized);
385+
358386
secp256k1_fe_impl_to_storage(r, a);
359387
}
360388

@@ -363,36 +391,42 @@ SECP256K1_INLINE static void secp256k1_fe_from_storage(secp256k1_fe *r, const se
363391
secp256k1_fe_impl_from_storage(r, a);
364392
r->magnitude = 1;
365393
r->normalized = 1;
366-
secp256k1_fe_verify(r);
394+
395+
SECP256K1_FE_VERIFY(r);
367396
}
368397

369398
static void secp256k1_fe_impl_inv(secp256k1_fe *r, const secp256k1_fe *x);
370399
SECP256K1_INLINE static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *x) {
371400
int input_is_zero = secp256k1_fe_normalizes_to_zero(x);
372-
secp256k1_fe_verify(x);
401+
SECP256K1_FE_VERIFY(x);
402+
373403
secp256k1_fe_impl_inv(r, x);
374404
r->magnitude = x->magnitude > 0;
375405
r->normalized = 1;
406+
376407
VERIFY_CHECK(secp256k1_fe_normalizes_to_zero(r) == input_is_zero);
377-
secp256k1_fe_verify(r);
408+
SECP256K1_FE_VERIFY(r);
378409
}
379410

380411
static void secp256k1_fe_impl_inv_var(secp256k1_fe *r, const secp256k1_fe *x);
381412
SECP256K1_INLINE static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *x) {
382413
int input_is_zero = secp256k1_fe_normalizes_to_zero(x);
383-
secp256k1_fe_verify(x);
414+
SECP256K1_FE_VERIFY(x);
415+
384416
secp256k1_fe_impl_inv_var(r, x);
385417
r->magnitude = x->magnitude > 0;
386418
r->normalized = 1;
419+
387420
VERIFY_CHECK(secp256k1_fe_normalizes_to_zero(r) == input_is_zero);
388-
secp256k1_fe_verify(r);
421+
SECP256K1_FE_VERIFY(r);
389422
}
390423

391424
static int secp256k1_fe_impl_is_square_var(const secp256k1_fe *x);
392425
SECP256K1_INLINE static int secp256k1_fe_is_square_var(const secp256k1_fe *x) {
393426
int ret;
394427
secp256k1_fe tmp = *x, sqrt;
395-
secp256k1_fe_verify(x);
428+
SECP256K1_FE_VERIFY(x);
429+
396430
ret = secp256k1_fe_impl_is_square_var(x);
397431
secp256k1_fe_normalize_weak(&tmp);
398432
VERIFY_CHECK(ret == secp256k1_fe_sqrt(&sqrt, &tmp));
@@ -403,20 +437,24 @@ static void secp256k1_fe_impl_get_bounds(secp256k1_fe* r, int m);
403437
SECP256K1_INLINE static void secp256k1_fe_get_bounds(secp256k1_fe* r, int m) {
404438
VERIFY_CHECK(m >= 0);
405439
VERIFY_CHECK(m <= 32);
440+
406441
secp256k1_fe_impl_get_bounds(r, m);
407442
r->magnitude = m;
408443
r->normalized = (m == 0);
409-
secp256k1_fe_verify(r);
444+
445+
SECP256K1_FE_VERIFY(r);
410446
}
411447

412448
static void secp256k1_fe_impl_half(secp256k1_fe *r);
413449
SECP256K1_INLINE static void secp256k1_fe_half(secp256k1_fe *r) {
414-
secp256k1_fe_verify(r);
415-
secp256k1_fe_verify_magnitude(r, 31);
450+
SECP256K1_FE_VERIFY(r);
451+
SECP256K1_FE_VERIFY_MAGNITUDE(r, 31);
452+
416453
secp256k1_fe_impl_half(r);
417454
r->magnitude = (r->magnitude >> 1) + 1;
418455
r->normalized = 0;
419-
secp256k1_fe_verify(r);
456+
457+
SECP256K1_FE_VERIFY(r);
420458
}
421459

422460
#endif /* defined(VERIFY) */

0 commit comments

Comments
 (0)