Bitcoin ABC 0.32.6
P2P Digital Currency
field_10x26_impl.h
Go to the documentation of this file.
1/***********************************************************************
2 * Copyright (c) 2013, 2014 Pieter Wuille *
3 * Distributed under the MIT software license, see the accompanying *
4 * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
5 ***********************************************************************/
6
7#ifndef SECP256K1_FIELD_REPR_IMPL_H
8#define SECP256K1_FIELD_REPR_IMPL_H
9
10#include "util.h"
11#include "field.h"
12#include "modinv32_impl.h"
13
14#ifdef VERIFY
15static void secp256k1_fe_verify(const secp256k1_fe *a) {
16 const uint32_t *d = a->n;
17 int m = a->normalized ? 1 : 2 * a->magnitude, r = 1;
18 r &= (d[0] <= 0x3FFFFFFUL * m);
19 r &= (d[1] <= 0x3FFFFFFUL * m);
20 r &= (d[2] <= 0x3FFFFFFUL * m);
21 r &= (d[3] <= 0x3FFFFFFUL * m);
22 r &= (d[4] <= 0x3FFFFFFUL * m);
23 r &= (d[5] <= 0x3FFFFFFUL * m);
24 r &= (d[6] <= 0x3FFFFFFUL * m);
25 r &= (d[7] <= 0x3FFFFFFUL * m);
26 r &= (d[8] <= 0x3FFFFFFUL * m);
27 r &= (d[9] <= 0x03FFFFFUL * m);
28 r &= (a->magnitude >= 0);
29 r &= (a->magnitude <= 32);
30 if (a->normalized) {
31 r &= (a->magnitude <= 1);
32 if (r && (d[9] == 0x03FFFFFUL)) {
33 uint32_t mid = d[8] & d[7] & d[6] & d[5] & d[4] & d[3] & d[2];
34 if (mid == 0x3FFFFFFUL) {
35 r &= ((d[1] + 0x40UL + ((d[0] + 0x3D1UL) >> 26)) <= 0x3FFFFFFUL);
36 }
37 }
38 }
39 VERIFY_CHECK(r == 1);
40}
41#endif
42
43static void secp256k1_fe_normalize(secp256k1_fe *r) {
44 uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
45 t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
46
47 /* Reduce t9 at the start so there will be at most a single carry from the first pass */
48 uint32_t m;
49 uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
50
51 /* The first pass ensures the magnitude is 1, ... */
52 t0 += x * 0x3D1UL; t1 += (x << 6);
53 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
54 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
55 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
56 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
57 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
58 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
59 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
60 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
61 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
62
63 /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
64 VERIFY_CHECK(t9 >> 23 == 0);
65
66 /* At most a single final reduction is needed; check if the value is >= the field characteristic */
67 x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
68 & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
69
70 /* Apply the final reduction (for constant-time behaviour, we do it always) */
71 t0 += x * 0x3D1UL; t1 += (x << 6);
72 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
73 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
74 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
75 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
76 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
77 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
78 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
79 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
80 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
81
82 /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
83 VERIFY_CHECK(t9 >> 22 == x);
84
85 /* Mask off the possible multiple of 2^256 from the final reduction */
86 t9 &= 0x03FFFFFUL;
87
88 r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
89 r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
90
91#ifdef VERIFY
92 r->magnitude = 1;
93 r->normalized = 1;
94 secp256k1_fe_verify(r);
95#endif
96}
97
98static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
99 uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
100 t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
101
102 /* Reduce t9 at the start so there will be at most a single carry from the first pass */
103 uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
104
105 /* The first pass ensures the magnitude is 1, ... */
106 t0 += x * 0x3D1UL; t1 += (x << 6);
107 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
108 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
109 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
110 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
111 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
112 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
113 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
114 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
115 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
116
117 /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
118 VERIFY_CHECK(t9 >> 23 == 0);
119
120 r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
121 r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
122
123#ifdef VERIFY
124 r->magnitude = 1;
125 secp256k1_fe_verify(r);
126#endif
127}
128
129static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
130 uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
131 t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
132
133 /* Reduce t9 at the start so there will be at most a single carry from the first pass */
134 uint32_t m;
135 uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
136
137 /* The first pass ensures the magnitude is 1, ... */
138 t0 += x * 0x3D1UL; t1 += (x << 6);
139 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
140 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
141 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; m = t2;
142 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; m &= t3;
143 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; m &= t4;
144 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; m &= t5;
145 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; m &= t6;
146 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; m &= t7;
147 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; m &= t8;
148
149 /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
150 VERIFY_CHECK(t9 >> 23 == 0);
151
152 /* At most a single final reduction is needed; check if the value is >= the field characteristic */
153 x = (t9 >> 22) | ((t9 == 0x03FFFFFUL) & (m == 0x3FFFFFFUL)
154 & ((t1 + 0x40UL + ((t0 + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
155
156 if (x) {
157 t0 += 0x3D1UL; t1 += (x << 6);
158 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL;
159 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL;
160 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL;
161 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL;
162 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL;
163 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL;
164 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL;
165 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL;
166 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL;
167
168 /* If t9 didn't carry to bit 22 already, then it should have after any final reduction */
169 VERIFY_CHECK(t9 >> 22 == x);
170
171 /* Mask off the possible multiple of 2^256 from the final reduction */
172 t9 &= 0x03FFFFFUL;
173 }
174
175 r->n[0] = t0; r->n[1] = t1; r->n[2] = t2; r->n[3] = t3; r->n[4] = t4;
176 r->n[5] = t5; r->n[6] = t6; r->n[7] = t7; r->n[8] = t8; r->n[9] = t9;
177
178#ifdef VERIFY
179 r->magnitude = 1;
180 r->normalized = 1;
181 secp256k1_fe_verify(r);
182#endif
183}
184
185static int secp256k1_fe_normalizes_to_zero(const secp256k1_fe *r) {
186 uint32_t t0 = r->n[0], t1 = r->n[1], t2 = r->n[2], t3 = r->n[3], t4 = r->n[4],
187 t5 = r->n[5], t6 = r->n[6], t7 = r->n[7], t8 = r->n[8], t9 = r->n[9];
188
189 /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
190 uint32_t z0, z1;
191
192 /* Reduce t9 at the start so there will be at most a single carry from the first pass */
193 uint32_t x = t9 >> 22; t9 &= 0x03FFFFFUL;
194
195 /* The first pass ensures the magnitude is 1, ... */
196 t0 += x * 0x3D1UL; t1 += (x << 6);
197 t1 += (t0 >> 26); t0 &= 0x3FFFFFFUL; z0 = t0; z1 = t0 ^ 0x3D0UL;
198 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
199 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
200 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
201 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
202 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
203 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
204 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
205 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
206 z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
207
208 /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
209 VERIFY_CHECK(t9 >> 23 == 0);
210
211 return (z0 == 0) | (z1 == 0x3FFFFFFUL);
212}
213
214static int secp256k1_fe_normalizes_to_zero_var(const secp256k1_fe *r) {
215 uint32_t t0, t1, t2, t3, t4, t5, t6, t7, t8, t9;
216 uint32_t z0, z1;
217 uint32_t x;
218
219 t0 = r->n[0];
220 t9 = r->n[9];
221
222 /* Reduce t9 at the start so there will be at most a single carry from the first pass */
223 x = t9 >> 22;
224
225 /* The first pass ensures the magnitude is 1, ... */
226 t0 += x * 0x3D1UL;
227
228 /* z0 tracks a possible raw value of 0, z1 tracks a possible raw value of P */
229 z0 = t0 & 0x3FFFFFFUL;
230 z1 = z0 ^ 0x3D0UL;
231
232 /* Fast return path should catch the majority of cases */
233 if ((z0 != 0UL) & (z1 != 0x3FFFFFFUL)) {
234 return 0;
235 }
236
237 t1 = r->n[1];
238 t2 = r->n[2];
239 t3 = r->n[3];
240 t4 = r->n[4];
241 t5 = r->n[5];
242 t6 = r->n[6];
243 t7 = r->n[7];
244 t8 = r->n[8];
245
246 t9 &= 0x03FFFFFUL;
247 t1 += (x << 6);
248
249 t1 += (t0 >> 26);
250 t2 += (t1 >> 26); t1 &= 0x3FFFFFFUL; z0 |= t1; z1 &= t1 ^ 0x40UL;
251 t3 += (t2 >> 26); t2 &= 0x3FFFFFFUL; z0 |= t2; z1 &= t2;
252 t4 += (t3 >> 26); t3 &= 0x3FFFFFFUL; z0 |= t3; z1 &= t3;
253 t5 += (t4 >> 26); t4 &= 0x3FFFFFFUL; z0 |= t4; z1 &= t4;
254 t6 += (t5 >> 26); t5 &= 0x3FFFFFFUL; z0 |= t5; z1 &= t5;
255 t7 += (t6 >> 26); t6 &= 0x3FFFFFFUL; z0 |= t6; z1 &= t6;
256 t8 += (t7 >> 26); t7 &= 0x3FFFFFFUL; z0 |= t7; z1 &= t7;
257 t9 += (t8 >> 26); t8 &= 0x3FFFFFFUL; z0 |= t8; z1 &= t8;
258 z0 |= t9; z1 &= t9 ^ 0x3C00000UL;
259
260 /* ... except for a possible carry at bit 22 of t9 (i.e. bit 256 of the field element) */
261 VERIFY_CHECK(t9 >> 23 == 0);
262
263 return (z0 == 0) | (z1 == 0x3FFFFFFUL);
264}
265
266SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
267 VERIFY_CHECK(0 <= a && a <= 0x7FFF);
268 r->n[0] = a;
269 r->n[1] = r->n[2] = r->n[3] = r->n[4] = r->n[5] = r->n[6] = r->n[7] = r->n[8] = r->n[9] = 0;
270#ifdef VERIFY
271 r->magnitude = (a != 0);
272 r->normalized = 1;
273 secp256k1_fe_verify(r);
274#endif
275}
276
277SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
278 const uint32_t *t = a->n;
279#ifdef VERIFY
280 VERIFY_CHECK(a->normalized);
281 secp256k1_fe_verify(a);
282#endif
283 return (t[0] | t[1] | t[2] | t[3] | t[4] | t[5] | t[6] | t[7] | t[8] | t[9]) == 0;
284}
285
286SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
287#ifdef VERIFY
288 VERIFY_CHECK(a->normalized);
289 secp256k1_fe_verify(a);
290#endif
291 return a->n[0] & 1;
292}
293
294SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
295 int i;
296#ifdef VERIFY
297 a->magnitude = 0;
298 a->normalized = 1;
299#endif
300 for (i=0; i<10; i++) {
301 a->n[i] = 0;
302 }
303}
304
305static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b) {
306 int i;
307#ifdef VERIFY
308 VERIFY_CHECK(a->normalized);
309 VERIFY_CHECK(b->normalized);
310 secp256k1_fe_verify(a);
311 secp256k1_fe_verify(b);
312#endif
313 for (i = 9; i >= 0; i--) {
314 if (a->n[i] > b->n[i]) {
315 return 1;
316 }
317 if (a->n[i] < b->n[i]) {
318 return -1;
319 }
320 }
321 return 0;
322}
323
324static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
325 int ret;
326 r->n[0] = (uint32_t)a[31] | ((uint32_t)a[30] << 8) | ((uint32_t)a[29] << 16) | ((uint32_t)(a[28] & 0x3) << 24);
327 r->n[1] = (uint32_t)((a[28] >> 2) & 0x3f) | ((uint32_t)a[27] << 6) | ((uint32_t)a[26] << 14) | ((uint32_t)(a[25] & 0xf) << 22);
328 r->n[2] = (uint32_t)((a[25] >> 4) & 0xf) | ((uint32_t)a[24] << 4) | ((uint32_t)a[23] << 12) | ((uint32_t)(a[22] & 0x3f) << 20);
329 r->n[3] = (uint32_t)((a[22] >> 6) & 0x3) | ((uint32_t)a[21] << 2) | ((uint32_t)a[20] << 10) | ((uint32_t)a[19] << 18);
330 r->n[4] = (uint32_t)a[18] | ((uint32_t)a[17] << 8) | ((uint32_t)a[16] << 16) | ((uint32_t)(a[15] & 0x3) << 24);
331 r->n[5] = (uint32_t)((a[15] >> 2) & 0x3f) | ((uint32_t)a[14] << 6) | ((uint32_t)a[13] << 14) | ((uint32_t)(a[12] & 0xf) << 22);
332 r->n[6] = (uint32_t)((a[12] >> 4) & 0xf) | ((uint32_t)a[11] << 4) | ((uint32_t)a[10] << 12) | ((uint32_t)(a[9] & 0x3f) << 20);
333 r->n[7] = (uint32_t)((a[9] >> 6) & 0x3) | ((uint32_t)a[8] << 2) | ((uint32_t)a[7] << 10) | ((uint32_t)a[6] << 18);
334 r->n[8] = (uint32_t)a[5] | ((uint32_t)a[4] << 8) | ((uint32_t)a[3] << 16) | ((uint32_t)(a[2] & 0x3) << 24);
335 r->n[9] = (uint32_t)((a[2] >> 2) & 0x3f) | ((uint32_t)a[1] << 6) | ((uint32_t)a[0] << 14);
336
337 ret = !((r->n[9] == 0x3FFFFFUL) & ((r->n[8] & r->n[7] & r->n[6] & r->n[5] & r->n[4] & r->n[3] & r->n[2]) == 0x3FFFFFFUL) & ((r->n[1] + 0x40UL + ((r->n[0] + 0x3D1UL) >> 26)) > 0x3FFFFFFUL));
338#ifdef VERIFY
339 r->magnitude = 1;
340 if (ret) {
341 r->normalized = 1;
342 secp256k1_fe_verify(r);
343 } else {
344 r->normalized = 0;
345 }
346#endif
347 return ret;
348}
349
351static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
352#ifdef VERIFY
353 VERIFY_CHECK(a->normalized);
354 secp256k1_fe_verify(a);
355#endif
356 r[0] = (a->n[9] >> 14) & 0xff;
357 r[1] = (a->n[9] >> 6) & 0xff;
358 r[2] = ((a->n[9] & 0x3F) << 2) | ((a->n[8] >> 24) & 0x3);
359 r[3] = (a->n[8] >> 16) & 0xff;
360 r[4] = (a->n[8] >> 8) & 0xff;
361 r[5] = a->n[8] & 0xff;
362 r[6] = (a->n[7] >> 18) & 0xff;
363 r[7] = (a->n[7] >> 10) & 0xff;
364 r[8] = (a->n[7] >> 2) & 0xff;
365 r[9] = ((a->n[7] & 0x3) << 6) | ((a->n[6] >> 20) & 0x3f);
366 r[10] = (a->n[6] >> 12) & 0xff;
367 r[11] = (a->n[6] >> 4) & 0xff;
368 r[12] = ((a->n[6] & 0xf) << 4) | ((a->n[5] >> 22) & 0xf);
369 r[13] = (a->n[5] >> 14) & 0xff;
370 r[14] = (a->n[5] >> 6) & 0xff;
371 r[15] = ((a->n[5] & 0x3f) << 2) | ((a->n[4] >> 24) & 0x3);
372 r[16] = (a->n[4] >> 16) & 0xff;
373 r[17] = (a->n[4] >> 8) & 0xff;
374 r[18] = a->n[4] & 0xff;
375 r[19] = (a->n[3] >> 18) & 0xff;
376 r[20] = (a->n[3] >> 10) & 0xff;
377 r[21] = (a->n[3] >> 2) & 0xff;
378 r[22] = ((a->n[3] & 0x3) << 6) | ((a->n[2] >> 20) & 0x3f);
379 r[23] = (a->n[2] >> 12) & 0xff;
380 r[24] = (a->n[2] >> 4) & 0xff;
381 r[25] = ((a->n[2] & 0xf) << 4) | ((a->n[1] >> 22) & 0xf);
382 r[26] = (a->n[1] >> 14) & 0xff;
383 r[27] = (a->n[1] >> 6) & 0xff;
384 r[28] = ((a->n[1] & 0x3f) << 2) | ((a->n[0] >> 24) & 0x3);
385 r[29] = (a->n[0] >> 16) & 0xff;
386 r[30] = (a->n[0] >> 8) & 0xff;
387 r[31] = a->n[0] & 0xff;
388}
389
390SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m) {
391#ifdef VERIFY
392 VERIFY_CHECK(a->magnitude <= m);
393 secp256k1_fe_verify(a);
394#endif
395 r->n[0] = 0x3FFFC2FUL * 2 * (m + 1) - a->n[0];
396 r->n[1] = 0x3FFFFBFUL * 2 * (m + 1) - a->n[1];
397 r->n[2] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[2];
398 r->n[3] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[3];
399 r->n[4] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[4];
400 r->n[5] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[5];
401 r->n[6] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[6];
402 r->n[7] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[7];
403 r->n[8] = 0x3FFFFFFUL * 2 * (m + 1) - a->n[8];
404 r->n[9] = 0x03FFFFFUL * 2 * (m + 1) - a->n[9];
405#ifdef VERIFY
406 r->magnitude = m + 1;
407 r->normalized = 0;
408 secp256k1_fe_verify(r);
409#endif
410}
411
412SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
413 r->n[0] *= a;
414 r->n[1] *= a;
415 r->n[2] *= a;
416 r->n[3] *= a;
417 r->n[4] *= a;
418 r->n[5] *= a;
419 r->n[6] *= a;
420 r->n[7] *= a;
421 r->n[8] *= a;
422 r->n[9] *= a;
423#ifdef VERIFY
424 r->magnitude *= a;
425 r->normalized = 0;
426 secp256k1_fe_verify(r);
427#endif
428}
429
430SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a) {
431#ifdef VERIFY
432 secp256k1_fe_verify(a);
433#endif
434 r->n[0] += a->n[0];
435 r->n[1] += a->n[1];
436 r->n[2] += a->n[2];
437 r->n[3] += a->n[3];
438 r->n[4] += a->n[4];
439 r->n[5] += a->n[5];
440 r->n[6] += a->n[6];
441 r->n[7] += a->n[7];
442 r->n[8] += a->n[8];
443 r->n[9] += a->n[9];
444#ifdef VERIFY
445 r->magnitude += a->magnitude;
446 r->normalized = 0;
447 secp256k1_fe_verify(r);
448#endif
449}
450
451#if defined(USE_EXTERNAL_ASM)
452
453/* External assembler implementation */
454void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t * SECP256K1_RESTRICT b);
455void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a);
456
457#else
458
459#ifdef VERIFY
460#define VERIFY_BITS(x, n) VERIFY_CHECK(((x) >> (n)) == 0)
461#else
462#define VERIFY_BITS(x, n) do { } while(0)
463#endif
464
465SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t * SECP256K1_RESTRICT b) {
466 uint64_t c, d;
467 uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
468 uint32_t t9, t1, t0, t2, t3, t4, t5, t6, t7;
469 const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
470
471 VERIFY_BITS(a[0], 30);
472 VERIFY_BITS(a[1], 30);
473 VERIFY_BITS(a[2], 30);
474 VERIFY_BITS(a[3], 30);
475 VERIFY_BITS(a[4], 30);
476 VERIFY_BITS(a[5], 30);
477 VERIFY_BITS(a[6], 30);
478 VERIFY_BITS(a[7], 30);
479 VERIFY_BITS(a[8], 30);
480 VERIFY_BITS(a[9], 26);
481 VERIFY_BITS(b[0], 30);
482 VERIFY_BITS(b[1], 30);
483 VERIFY_BITS(b[2], 30);
484 VERIFY_BITS(b[3], 30);
485 VERIFY_BITS(b[4], 30);
486 VERIFY_BITS(b[5], 30);
487 VERIFY_BITS(b[6], 30);
488 VERIFY_BITS(b[7], 30);
489 VERIFY_BITS(b[8], 30);
490 VERIFY_BITS(b[9], 26);
491
498 d = (uint64_t)a[0] * b[9]
499 + (uint64_t)a[1] * b[8]
500 + (uint64_t)a[2] * b[7]
501 + (uint64_t)a[3] * b[6]
502 + (uint64_t)a[4] * b[5]
503 + (uint64_t)a[5] * b[4]
504 + (uint64_t)a[6] * b[3]
505 + (uint64_t)a[7] * b[2]
506 + (uint64_t)a[8] * b[1]
507 + (uint64_t)a[9] * b[0];
508 /* VERIFY_BITS(d, 64); */
509 /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
510 t9 = d & M; d >>= 26;
511 VERIFY_BITS(t9, 26);
512 VERIFY_BITS(d, 38);
513 /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
514
515 c = (uint64_t)a[0] * b[0];
516 VERIFY_BITS(c, 60);
517 /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
518 d += (uint64_t)a[1] * b[9]
519 + (uint64_t)a[2] * b[8]
520 + (uint64_t)a[3] * b[7]
521 + (uint64_t)a[4] * b[6]
522 + (uint64_t)a[5] * b[5]
523 + (uint64_t)a[6] * b[4]
524 + (uint64_t)a[7] * b[3]
525 + (uint64_t)a[8] * b[2]
526 + (uint64_t)a[9] * b[1];
527 VERIFY_BITS(d, 63);
528 /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
529 u0 = d & M; d >>= 26; c += u0 * R0;
530 VERIFY_BITS(u0, 26);
531 VERIFY_BITS(d, 37);
532 VERIFY_BITS(c, 61);
533 /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
534 t0 = c & M; c >>= 26; c += u0 * R1;
535 VERIFY_BITS(t0, 26);
536 VERIFY_BITS(c, 37);
537 /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
538 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
539
540 c += (uint64_t)a[0] * b[1]
541 + (uint64_t)a[1] * b[0];
542 VERIFY_BITS(c, 62);
543 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
544 d += (uint64_t)a[2] * b[9]
545 + (uint64_t)a[3] * b[8]
546 + (uint64_t)a[4] * b[7]
547 + (uint64_t)a[5] * b[6]
548 + (uint64_t)a[6] * b[5]
549 + (uint64_t)a[7] * b[4]
550 + (uint64_t)a[8] * b[3]
551 + (uint64_t)a[9] * b[2];
552 VERIFY_BITS(d, 63);
553 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
554 u1 = d & M; d >>= 26; c += u1 * R0;
555 VERIFY_BITS(u1, 26);
556 VERIFY_BITS(d, 37);
557 VERIFY_BITS(c, 63);
558 /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
559 t1 = c & M; c >>= 26; c += u1 * R1;
560 VERIFY_BITS(t1, 26);
561 VERIFY_BITS(c, 38);
562 /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
563 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
564
565 c += (uint64_t)a[0] * b[2]
566 + (uint64_t)a[1] * b[1]
567 + (uint64_t)a[2] * b[0];
568 VERIFY_BITS(c, 62);
569 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
570 d += (uint64_t)a[3] * b[9]
571 + (uint64_t)a[4] * b[8]
572 + (uint64_t)a[5] * b[7]
573 + (uint64_t)a[6] * b[6]
574 + (uint64_t)a[7] * b[5]
575 + (uint64_t)a[8] * b[4]
576 + (uint64_t)a[9] * b[3];
577 VERIFY_BITS(d, 63);
578 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
579 u2 = d & M; d >>= 26; c += u2 * R0;
580 VERIFY_BITS(u2, 26);
581 VERIFY_BITS(d, 37);
582 VERIFY_BITS(c, 63);
583 /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
584 t2 = c & M; c >>= 26; c += u2 * R1;
585 VERIFY_BITS(t2, 26);
586 VERIFY_BITS(c, 38);
587 /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
588 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
589
590 c += (uint64_t)a[0] * b[3]
591 + (uint64_t)a[1] * b[2]
592 + (uint64_t)a[2] * b[1]
593 + (uint64_t)a[3] * b[0];
594 VERIFY_BITS(c, 63);
595 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
596 d += (uint64_t)a[4] * b[9]
597 + (uint64_t)a[5] * b[8]
598 + (uint64_t)a[6] * b[7]
599 + (uint64_t)a[7] * b[6]
600 + (uint64_t)a[8] * b[5]
601 + (uint64_t)a[9] * b[4];
602 VERIFY_BITS(d, 63);
603 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
604 u3 = d & M; d >>= 26; c += u3 * R0;
605 VERIFY_BITS(u3, 26);
606 VERIFY_BITS(d, 37);
607 /* VERIFY_BITS(c, 64); */
608 /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
609 t3 = c & M; c >>= 26; c += u3 * R1;
610 VERIFY_BITS(t3, 26);
611 VERIFY_BITS(c, 39);
612 /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
613 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
614
615 c += (uint64_t)a[0] * b[4]
616 + (uint64_t)a[1] * b[3]
617 + (uint64_t)a[2] * b[2]
618 + (uint64_t)a[3] * b[1]
619 + (uint64_t)a[4] * b[0];
620 VERIFY_BITS(c, 63);
621 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
622 d += (uint64_t)a[5] * b[9]
623 + (uint64_t)a[6] * b[8]
624 + (uint64_t)a[7] * b[7]
625 + (uint64_t)a[8] * b[6]
626 + (uint64_t)a[9] * b[5];
627 VERIFY_BITS(d, 62);
628 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
629 u4 = d & M; d >>= 26; c += u4 * R0;
630 VERIFY_BITS(u4, 26);
631 VERIFY_BITS(d, 36);
632 /* VERIFY_BITS(c, 64); */
633 /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
634 t4 = c & M; c >>= 26; c += u4 * R1;
635 VERIFY_BITS(t4, 26);
636 VERIFY_BITS(c, 39);
637 /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
638 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
639
640 c += (uint64_t)a[0] * b[5]
641 + (uint64_t)a[1] * b[4]
642 + (uint64_t)a[2] * b[3]
643 + (uint64_t)a[3] * b[2]
644 + (uint64_t)a[4] * b[1]
645 + (uint64_t)a[5] * b[0];
646 VERIFY_BITS(c, 63);
647 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
648 d += (uint64_t)a[6] * b[9]
649 + (uint64_t)a[7] * b[8]
650 + (uint64_t)a[8] * b[7]
651 + (uint64_t)a[9] * b[6];
652 VERIFY_BITS(d, 62);
653 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
654 u5 = d & M; d >>= 26; c += u5 * R0;
655 VERIFY_BITS(u5, 26);
656 VERIFY_BITS(d, 36);
657 /* VERIFY_BITS(c, 64); */
658 /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
659 t5 = c & M; c >>= 26; c += u5 * R1;
660 VERIFY_BITS(t5, 26);
661 VERIFY_BITS(c, 39);
662 /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
663 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
664
665 c += (uint64_t)a[0] * b[6]
666 + (uint64_t)a[1] * b[5]
667 + (uint64_t)a[2] * b[4]
668 + (uint64_t)a[3] * b[3]
669 + (uint64_t)a[4] * b[2]
670 + (uint64_t)a[5] * b[1]
671 + (uint64_t)a[6] * b[0];
672 VERIFY_BITS(c, 63);
673 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
674 d += (uint64_t)a[7] * b[9]
675 + (uint64_t)a[8] * b[8]
676 + (uint64_t)a[9] * b[7];
677 VERIFY_BITS(d, 61);
678 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
679 u6 = d & M; d >>= 26; c += u6 * R0;
680 VERIFY_BITS(u6, 26);
681 VERIFY_BITS(d, 35);
682 /* VERIFY_BITS(c, 64); */
683 /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
684 t6 = c & M; c >>= 26; c += u6 * R1;
685 VERIFY_BITS(t6, 26);
686 VERIFY_BITS(c, 39);
687 /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
688 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
689
690 c += (uint64_t)a[0] * b[7]
691 + (uint64_t)a[1] * b[6]
692 + (uint64_t)a[2] * b[5]
693 + (uint64_t)a[3] * b[4]
694 + (uint64_t)a[4] * b[3]
695 + (uint64_t)a[5] * b[2]
696 + (uint64_t)a[6] * b[1]
697 + (uint64_t)a[7] * b[0];
698 /* VERIFY_BITS(c, 64); */
699 VERIFY_CHECK(c <= 0x8000007C00000007ULL);
700 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
701 d += (uint64_t)a[8] * b[9]
702 + (uint64_t)a[9] * b[8];
703 VERIFY_BITS(d, 58);
704 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
705 u7 = d & M; d >>= 26; c += u7 * R0;
706 VERIFY_BITS(u7, 26);
707 VERIFY_BITS(d, 32);
708 /* VERIFY_BITS(c, 64); */
709 VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
710 /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
711 t7 = c & M; c >>= 26; c += u7 * R1;
712 VERIFY_BITS(t7, 26);
713 VERIFY_BITS(c, 38);
714 /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
715 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
716
717 c += (uint64_t)a[0] * b[8]
718 + (uint64_t)a[1] * b[7]
719 + (uint64_t)a[2] * b[6]
720 + (uint64_t)a[3] * b[5]
721 + (uint64_t)a[4] * b[4]
722 + (uint64_t)a[5] * b[3]
723 + (uint64_t)a[6] * b[2]
724 + (uint64_t)a[7] * b[1]
725 + (uint64_t)a[8] * b[0];
726 /* VERIFY_BITS(c, 64); */
727 VERIFY_CHECK(c <= 0x9000007B80000008ULL);
728 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
729 d += (uint64_t)a[9] * b[9];
730 VERIFY_BITS(d, 57);
731 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
732 u8 = d & M; d >>= 26; c += u8 * R0;
733 VERIFY_BITS(u8, 26);
734 VERIFY_BITS(d, 31);
735 /* VERIFY_BITS(c, 64); */
736 VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
737 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
738
739 r[3] = t3;
740 VERIFY_BITS(r[3], 26);
741 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
742 r[4] = t4;
743 VERIFY_BITS(r[4], 26);
744 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
745 r[5] = t5;
746 VERIFY_BITS(r[5], 26);
747 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
748 r[6] = t6;
749 VERIFY_BITS(r[6], 26);
750 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
751 r[7] = t7;
752 VERIFY_BITS(r[7], 26);
753 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
754
755 r[8] = c & M; c >>= 26; c += u8 * R1;
756 VERIFY_BITS(r[8], 26);
757 VERIFY_BITS(c, 39);
758 /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
759 /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
760 c += d * R0 + t9;
761 VERIFY_BITS(c, 45);
762 /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
763 r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
764 VERIFY_BITS(r[9], 22);
765 VERIFY_BITS(c, 46);
766 /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
767 /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
768 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
769
770 d = c * (R0 >> 4) + t0;
771 VERIFY_BITS(d, 56);
772 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
773 r[0] = d & M; d >>= 26;
774 VERIFY_BITS(r[0], 26);
775 VERIFY_BITS(d, 30);
776 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
777 d += c * (R1 >> 4) + t1;
778 VERIFY_BITS(d, 53);
779 VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
780 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
781 /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
782 r[1] = d & M; d >>= 26;
783 VERIFY_BITS(r[1], 26);
784 VERIFY_BITS(d, 27);
785 VERIFY_CHECK(d <= 0x4000000ULL);
786 /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
787 d += t2;
788 VERIFY_BITS(d, 27);
789 /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
790 r[2] = d;
791 VERIFY_BITS(r[2], 27);
792 /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
793}
794
795SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a) {
796 uint64_t c, d;
797 uint64_t u0, u1, u2, u3, u4, u5, u6, u7, u8;
798 uint32_t t9, t0, t1, t2, t3, t4, t5, t6, t7;
799 const uint32_t M = 0x3FFFFFFUL, R0 = 0x3D10UL, R1 = 0x400UL;
800
801 VERIFY_BITS(a[0], 30);
802 VERIFY_BITS(a[1], 30);
803 VERIFY_BITS(a[2], 30);
804 VERIFY_BITS(a[3], 30);
805 VERIFY_BITS(a[4], 30);
806 VERIFY_BITS(a[5], 30);
807 VERIFY_BITS(a[6], 30);
808 VERIFY_BITS(a[7], 30);
809 VERIFY_BITS(a[8], 30);
810 VERIFY_BITS(a[9], 26);
811
817 d = (uint64_t)(a[0]*2) * a[9]
818 + (uint64_t)(a[1]*2) * a[8]
819 + (uint64_t)(a[2]*2) * a[7]
820 + (uint64_t)(a[3]*2) * a[6]
821 + (uint64_t)(a[4]*2) * a[5];
822 /* VERIFY_BITS(d, 64); */
823 /* [d 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
824 t9 = d & M; d >>= 26;
825 VERIFY_BITS(t9, 26);
826 VERIFY_BITS(d, 38);
827 /* [d t9 0 0 0 0 0 0 0 0 0] = [p9 0 0 0 0 0 0 0 0 0] */
828
829 c = (uint64_t)a[0] * a[0];
830 VERIFY_BITS(c, 60);
831 /* [d t9 0 0 0 0 0 0 0 0 c] = [p9 0 0 0 0 0 0 0 0 p0] */
832 d += (uint64_t)(a[1]*2) * a[9]
833 + (uint64_t)(a[2]*2) * a[8]
834 + (uint64_t)(a[3]*2) * a[7]
835 + (uint64_t)(a[4]*2) * a[6]
836 + (uint64_t)a[5] * a[5];
837 VERIFY_BITS(d, 63);
838 /* [d t9 0 0 0 0 0 0 0 0 c] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
839 u0 = d & M; d >>= 26; c += u0 * R0;
840 VERIFY_BITS(u0, 26);
841 VERIFY_BITS(d, 37);
842 VERIFY_BITS(c, 61);
843 /* [d u0 t9 0 0 0 0 0 0 0 0 c-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
844 t0 = c & M; c >>= 26; c += u0 * R1;
845 VERIFY_BITS(t0, 26);
846 VERIFY_BITS(c, 37);
847 /* [d u0 t9 0 0 0 0 0 0 0 c-u0*R1 t0-u0*R0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
848 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 0 p0] */
849
850 c += (uint64_t)(a[0]*2) * a[1];
851 VERIFY_BITS(c, 62);
852 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p10 p9 0 0 0 0 0 0 0 p1 p0] */
853 d += (uint64_t)(a[2]*2) * a[9]
854 + (uint64_t)(a[3]*2) * a[8]
855 + (uint64_t)(a[4]*2) * a[7]
856 + (uint64_t)(a[5]*2) * a[6];
857 VERIFY_BITS(d, 63);
858 /* [d 0 t9 0 0 0 0 0 0 0 c t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
859 u1 = d & M; d >>= 26; c += u1 * R0;
860 VERIFY_BITS(u1, 26);
861 VERIFY_BITS(d, 37);
862 VERIFY_BITS(c, 63);
863 /* [d u1 0 t9 0 0 0 0 0 0 0 c-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
864 t1 = c & M; c >>= 26; c += u1 * R1;
865 VERIFY_BITS(t1, 26);
866 VERIFY_BITS(c, 38);
867 /* [d u1 0 t9 0 0 0 0 0 0 c-u1*R1 t1-u1*R0 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
868 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 0 p1 p0] */
869
870 c += (uint64_t)(a[0]*2) * a[2]
871 + (uint64_t)a[1] * a[1];
872 VERIFY_BITS(c, 62);
873 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
874 d += (uint64_t)(a[3]*2) * a[9]
875 + (uint64_t)(a[4]*2) * a[8]
876 + (uint64_t)(a[5]*2) * a[7]
877 + (uint64_t)a[6] * a[6];
878 VERIFY_BITS(d, 63);
879 /* [d 0 0 t9 0 0 0 0 0 0 c t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
880 u2 = d & M; d >>= 26; c += u2 * R0;
881 VERIFY_BITS(u2, 26);
882 VERIFY_BITS(d, 37);
883 VERIFY_BITS(c, 63);
884 /* [d u2 0 0 t9 0 0 0 0 0 0 c-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
885 t2 = c & M; c >>= 26; c += u2 * R1;
886 VERIFY_BITS(t2, 26);
887 VERIFY_BITS(c, 38);
888 /* [d u2 0 0 t9 0 0 0 0 0 c-u2*R1 t2-u2*R0 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
889 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 0 p2 p1 p0] */
890
891 c += (uint64_t)(a[0]*2) * a[3]
892 + (uint64_t)(a[1]*2) * a[2];
893 VERIFY_BITS(c, 63);
894 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
895 d += (uint64_t)(a[4]*2) * a[9]
896 + (uint64_t)(a[5]*2) * a[8]
897 + (uint64_t)(a[6]*2) * a[7];
898 VERIFY_BITS(d, 63);
899 /* [d 0 0 0 t9 0 0 0 0 0 c t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
900 u3 = d & M; d >>= 26; c += u3 * R0;
901 VERIFY_BITS(u3, 26);
902 VERIFY_BITS(d, 37);
903 /* VERIFY_BITS(c, 64); */
904 /* [d u3 0 0 0 t9 0 0 0 0 0 c-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
905 t3 = c & M; c >>= 26; c += u3 * R1;
906 VERIFY_BITS(t3, 26);
907 VERIFY_BITS(c, 39);
908 /* [d u3 0 0 0 t9 0 0 0 0 c-u3*R1 t3-u3*R0 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
909 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 0 p3 p2 p1 p0] */
910
911 c += (uint64_t)(a[0]*2) * a[4]
912 + (uint64_t)(a[1]*2) * a[3]
913 + (uint64_t)a[2] * a[2];
914 VERIFY_BITS(c, 63);
915 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
916 d += (uint64_t)(a[5]*2) * a[9]
917 + (uint64_t)(a[6]*2) * a[8]
918 + (uint64_t)a[7] * a[7];
919 VERIFY_BITS(d, 62);
920 /* [d 0 0 0 0 t9 0 0 0 0 c t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
921 u4 = d & M; d >>= 26; c += u4 * R0;
922 VERIFY_BITS(u4, 26);
923 VERIFY_BITS(d, 36);
924 /* VERIFY_BITS(c, 64); */
925 /* [d u4 0 0 0 0 t9 0 0 0 0 c-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
926 t4 = c & M; c >>= 26; c += u4 * R1;
927 VERIFY_BITS(t4, 26);
928 VERIFY_BITS(c, 39);
929 /* [d u4 0 0 0 0 t9 0 0 0 c-u4*R1 t4-u4*R0 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
930 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 0 p4 p3 p2 p1 p0] */
931
932 c += (uint64_t)(a[0]*2) * a[5]
933 + (uint64_t)(a[1]*2) * a[4]
934 + (uint64_t)(a[2]*2) * a[3];
935 VERIFY_BITS(c, 63);
936 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
937 d += (uint64_t)(a[6]*2) * a[9]
938 + (uint64_t)(a[7]*2) * a[8];
939 VERIFY_BITS(d, 62);
940 /* [d 0 0 0 0 0 t9 0 0 0 c t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
941 u5 = d & M; d >>= 26; c += u5 * R0;
942 VERIFY_BITS(u5, 26);
943 VERIFY_BITS(d, 36);
944 /* VERIFY_BITS(c, 64); */
945 /* [d u5 0 0 0 0 0 t9 0 0 0 c-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
946 t5 = c & M; c >>= 26; c += u5 * R1;
947 VERIFY_BITS(t5, 26);
948 VERIFY_BITS(c, 39);
949 /* [d u5 0 0 0 0 0 t9 0 0 c-u5*R1 t5-u5*R0 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
950 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 0 p5 p4 p3 p2 p1 p0] */
951
952 c += (uint64_t)(a[0]*2) * a[6]
953 + (uint64_t)(a[1]*2) * a[5]
954 + (uint64_t)(a[2]*2) * a[4]
955 + (uint64_t)a[3] * a[3];
956 VERIFY_BITS(c, 63);
957 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
958 d += (uint64_t)(a[7]*2) * a[9]
959 + (uint64_t)a[8] * a[8];
960 VERIFY_BITS(d, 61);
961 /* [d 0 0 0 0 0 0 t9 0 0 c t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
962 u6 = d & M; d >>= 26; c += u6 * R0;
963 VERIFY_BITS(u6, 26);
964 VERIFY_BITS(d, 35);
965 /* VERIFY_BITS(c, 64); */
966 /* [d u6 0 0 0 0 0 0 t9 0 0 c-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
967 t6 = c & M; c >>= 26; c += u6 * R1;
968 VERIFY_BITS(t6, 26);
969 VERIFY_BITS(c, 39);
970 /* [d u6 0 0 0 0 0 0 t9 0 c-u6*R1 t6-u6*R0 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
971 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 0 p6 p5 p4 p3 p2 p1 p0] */
972
973 c += (uint64_t)(a[0]*2) * a[7]
974 + (uint64_t)(a[1]*2) * a[6]
975 + (uint64_t)(a[2]*2) * a[5]
976 + (uint64_t)(a[3]*2) * a[4];
977 /* VERIFY_BITS(c, 64); */
978 VERIFY_CHECK(c <= 0x8000007C00000007ULL);
979 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
980 d += (uint64_t)(a[8]*2) * a[9];
981 VERIFY_BITS(d, 58);
982 /* [d 0 0 0 0 0 0 0 t9 0 c t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
983 u7 = d & M; d >>= 26; c += u7 * R0;
984 VERIFY_BITS(u7, 26);
985 VERIFY_BITS(d, 32);
986 /* VERIFY_BITS(c, 64); */
987 VERIFY_CHECK(c <= 0x800001703FFFC2F7ULL);
988 /* [d u7 0 0 0 0 0 0 0 t9 0 c-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
989 t7 = c & M; c >>= 26; c += u7 * R1;
990 VERIFY_BITS(t7, 26);
991 VERIFY_BITS(c, 38);
992 /* [d u7 0 0 0 0 0 0 0 t9 c-u7*R1 t7-u7*R0 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
993 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 0 p7 p6 p5 p4 p3 p2 p1 p0] */
994
995 c += (uint64_t)(a[0]*2) * a[8]
996 + (uint64_t)(a[1]*2) * a[7]
997 + (uint64_t)(a[2]*2) * a[6]
998 + (uint64_t)(a[3]*2) * a[5]
999 + (uint64_t)a[4] * a[4];
1000 /* VERIFY_BITS(c, 64); */
1001 VERIFY_CHECK(c <= 0x9000007B80000008ULL);
1002 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1003 d += (uint64_t)a[9] * a[9];
1004 VERIFY_BITS(d, 57);
1005 /* [d 0 0 0 0 0 0 0 0 t9 c t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1006 u8 = d & M; d >>= 26; c += u8 * R0;
1007 VERIFY_BITS(u8, 26);
1008 VERIFY_BITS(d, 31);
1009 /* VERIFY_BITS(c, 64); */
1010 VERIFY_CHECK(c <= 0x9000016FBFFFC2F8ULL);
1011 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 t3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1012
1013 r[3] = t3;
1014 VERIFY_BITS(r[3], 26);
1015 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 t4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1016 r[4] = t4;
1017 VERIFY_BITS(r[4], 26);
1018 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 t5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1019 r[5] = t5;
1020 VERIFY_BITS(r[5], 26);
1021 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 t6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1022 r[6] = t6;
1023 VERIFY_BITS(r[6], 26);
1024 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 t7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1025 r[7] = t7;
1026 VERIFY_BITS(r[7], 26);
1027 /* [d u8 0 0 0 0 0 0 0 0 t9 c-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1028
1029 r[8] = c & M; c >>= 26; c += u8 * R1;
1030 VERIFY_BITS(r[8], 26);
1031 VERIFY_BITS(c, 39);
1032 /* [d u8 0 0 0 0 0 0 0 0 t9+c-u8*R1 r8-u8*R0 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1033 /* [d 0 0 0 0 0 0 0 0 0 t9+c r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1034 c += d * R0 + t9;
1035 VERIFY_BITS(c, 45);
1036 /* [d 0 0 0 0 0 0 0 0 0 c-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1037 r[9] = c & (M >> 4); c >>= 22; c += d * (R1 << 4);
1038 VERIFY_BITS(r[9], 22);
1039 VERIFY_BITS(c, 46);
1040 /* [d 0 0 0 0 0 0 0 0 r9+((c-d*R1<<4)<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1041 /* [d 0 0 0 0 0 0 0 -d*R1 r9+(c<<22)-d*R0 r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1042 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 t0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1043
1044 d = c * (R0 >> 4) + t0;
1045 VERIFY_BITS(d, 56);
1046 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1 d-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1047 r[0] = d & M; d >>= 26;
1048 VERIFY_BITS(r[0], 26);
1049 VERIFY_BITS(d, 30);
1050 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 t1+d r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1051 d += c * (R1 >> 4) + t1;
1052 VERIFY_BITS(d, 53);
1053 VERIFY_CHECK(d <= 0x10000003FFFFBFULL);
1054 /* [r9+(c<<22) r8 r7 r6 r5 r4 r3 t2 d-c*R1>>4 r0-c*R0>>4] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1055 /* [r9 r8 r7 r6 r5 r4 r3 t2 d r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1056 r[1] = d & M; d >>= 26;
1057 VERIFY_BITS(r[1], 26);
1058 VERIFY_BITS(d, 27);
1059 VERIFY_CHECK(d <= 0x4000000ULL);
1060 /* [r9 r8 r7 r6 r5 r4 r3 t2+d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1061 d += t2;
1062 VERIFY_BITS(d, 27);
1063 /* [r9 r8 r7 r6 r5 r4 r3 d r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1064 r[2] = d;
1065 VERIFY_BITS(r[2], 27);
1066 /* [r9 r8 r7 r6 r5 r4 r3 r2 r1 r0] = [p18 p17 p16 p15 p14 p13 p12 p11 p10 p9 p8 p7 p6 p5 p4 p3 p2 p1 p0] */
1067}
1068#endif
1069
1070static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe * SECP256K1_RESTRICT b) {
1071#ifdef VERIFY
1072 VERIFY_CHECK(a->magnitude <= 8);
1073 VERIFY_CHECK(b->magnitude <= 8);
1074 secp256k1_fe_verify(a);
1075 secp256k1_fe_verify(b);
1076 VERIFY_CHECK(r != b);
1077 VERIFY_CHECK(a != b);
1078#endif
1079 secp256k1_fe_mul_inner(r->n, a->n, b->n);
1080#ifdef VERIFY
1081 r->magnitude = 1;
1082 r->normalized = 0;
1083 secp256k1_fe_verify(r);
1084#endif
1085}
1086
1087static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
1088#ifdef VERIFY
1089 VERIFY_CHECK(a->magnitude <= 8);
1090 secp256k1_fe_verify(a);
1091#endif
1092 secp256k1_fe_sqr_inner(r->n, a->n);
1093#ifdef VERIFY
1094 r->magnitude = 1;
1095 r->normalized = 0;
1096 secp256k1_fe_verify(r);
1097#endif
1098}
1099
1100static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag) {
1101 uint32_t mask0, mask1;
1102 volatile int vflag = flag;
1103 VG_CHECK_VERIFY(r->n, sizeof(r->n));
1104 mask0 = vflag + ~((uint32_t)0);
1105 mask1 = ~mask0;
1106 r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
1107 r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
1108 r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
1109 r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
1110 r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
1111 r->n[5] = (r->n[5] & mask0) | (a->n[5] & mask1);
1112 r->n[6] = (r->n[6] & mask0) | (a->n[6] & mask1);
1113 r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
1114 r->n[8] = (r->n[8] & mask0) | (a->n[8] & mask1);
1115 r->n[9] = (r->n[9] & mask0) | (a->n[9] & mask1);
1116#ifdef VERIFY
1117 if (flag) {
1118 r->magnitude = a->magnitude;
1119 r->normalized = a->normalized;
1120 }
1121#endif
1122}
1123
1124static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag) {
1125 uint32_t mask0, mask1;
1126 volatile int vflag = flag;
1127 VG_CHECK_VERIFY(r->n, sizeof(r->n));
1128 mask0 = vflag + ~((uint32_t)0);
1129 mask1 = ~mask0;
1130 r->n[0] = (r->n[0] & mask0) | (a->n[0] & mask1);
1131 r->n[1] = (r->n[1] & mask0) | (a->n[1] & mask1);
1132 r->n[2] = (r->n[2] & mask0) | (a->n[2] & mask1);
1133 r->n[3] = (r->n[3] & mask0) | (a->n[3] & mask1);
1134 r->n[4] = (r->n[4] & mask0) | (a->n[4] & mask1);
1135 r->n[5] = (r->n[5] & mask0) | (a->n[5] & mask1);
1136 r->n[6] = (r->n[6] & mask0) | (a->n[6] & mask1);
1137 r->n[7] = (r->n[7] & mask0) | (a->n[7] & mask1);
1138}
1139
1140static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a) {
1141#ifdef VERIFY
1142 VERIFY_CHECK(a->normalized);
1143#endif
1144 r->n[0] = a->n[0] | a->n[1] << 26;
1145 r->n[1] = a->n[1] >> 6 | a->n[2] << 20;
1146 r->n[2] = a->n[2] >> 12 | a->n[3] << 14;
1147 r->n[3] = a->n[3] >> 18 | a->n[4] << 8;
1148 r->n[4] = a->n[4] >> 24 | a->n[5] << 2 | a->n[6] << 28;
1149 r->n[5] = a->n[6] >> 4 | a->n[7] << 22;
1150 r->n[6] = a->n[7] >> 10 | a->n[8] << 16;
1151 r->n[7] = a->n[8] >> 16 | a->n[9] << 10;
1152}
1153
1154static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a) {
1155 r->n[0] = a->n[0] & 0x3FFFFFFUL;
1156 r->n[1] = a->n[0] >> 26 | ((a->n[1] << 6) & 0x3FFFFFFUL);
1157 r->n[2] = a->n[1] >> 20 | ((a->n[2] << 12) & 0x3FFFFFFUL);
1158 r->n[3] = a->n[2] >> 14 | ((a->n[3] << 18) & 0x3FFFFFFUL);
1159 r->n[4] = a->n[3] >> 8 | ((a->n[4] << 24) & 0x3FFFFFFUL);
1160 r->n[5] = (a->n[4] >> 2) & 0x3FFFFFFUL;
1161 r->n[6] = a->n[4] >> 28 | ((a->n[5] << 4) & 0x3FFFFFFUL);
1162 r->n[7] = a->n[5] >> 22 | ((a->n[6] << 10) & 0x3FFFFFFUL);
1163 r->n[8] = a->n[6] >> 16 | ((a->n[7] << 16) & 0x3FFFFFFUL);
1164 r->n[9] = a->n[7] >> 10;
1165#ifdef VERIFY
1166 r->magnitude = 1;
1167 r->normalized = 1;
1168 secp256k1_fe_verify(r);
1169#endif
1170}
1171
1172static void secp256k1_fe_from_signed30(secp256k1_fe *r, const secp256k1_modinv32_signed30 *a) {
1173 const uint32_t M26 = UINT32_MAX >> 6;
1174 const uint32_t a0 = a->v[0], a1 = a->v[1], a2 = a->v[2], a3 = a->v[3], a4 = a->v[4],
1175 a5 = a->v[5], a6 = a->v[6], a7 = a->v[7], a8 = a->v[8];
1176
1177 /* The output from secp256k1_modinv32{_var} should be normalized to range [0,modulus), and
1178 * have limbs in [0,2^30). The modulus is < 2^256, so the top limb must be below 2^(256-30*8).
1179 */
1180 VERIFY_CHECK(a0 >> 30 == 0);
1181 VERIFY_CHECK(a1 >> 30 == 0);
1182 VERIFY_CHECK(a2 >> 30 == 0);
1183 VERIFY_CHECK(a3 >> 30 == 0);
1184 VERIFY_CHECK(a4 >> 30 == 0);
1185 VERIFY_CHECK(a5 >> 30 == 0);
1186 VERIFY_CHECK(a6 >> 30 == 0);
1187 VERIFY_CHECK(a7 >> 30 == 0);
1188 VERIFY_CHECK(a8 >> 16 == 0);
1189
1190 r->n[0] = a0 & M26;
1191 r->n[1] = (a0 >> 26 | a1 << 4) & M26;
1192 r->n[2] = (a1 >> 22 | a2 << 8) & M26;
1193 r->n[3] = (a2 >> 18 | a3 << 12) & M26;
1194 r->n[4] = (a3 >> 14 | a4 << 16) & M26;
1195 r->n[5] = (a4 >> 10 | a5 << 20) & M26;
1196 r->n[6] = (a5 >> 6 | a6 << 24) & M26;
1197 r->n[7] = (a6 >> 2 ) & M26;
1198 r->n[8] = (a6 >> 28 | a7 << 2) & M26;
1199 r->n[9] = (a7 >> 24 | a8 << 6);
1200
1201#ifdef VERIFY
1202 r->magnitude = 1;
1203 r->normalized = 1;
1204 secp256k1_fe_verify(r);
1205#endif
1206}
1207
1208static void secp256k1_fe_to_signed30(secp256k1_modinv32_signed30 *r, const secp256k1_fe *a) {
1209 const uint32_t M30 = UINT32_MAX >> 2;
1210 const uint64_t a0 = a->n[0], a1 = a->n[1], a2 = a->n[2], a3 = a->n[3], a4 = a->n[4],
1211 a5 = a->n[5], a6 = a->n[6], a7 = a->n[7], a8 = a->n[8], a9 = a->n[9];
1212
1213#ifdef VERIFY
1214 VERIFY_CHECK(a->normalized);
1215#endif
1216
1217 r->v[0] = (a0 | a1 << 26) & M30;
1218 r->v[1] = (a1 >> 4 | a2 << 22) & M30;
1219 r->v[2] = (a2 >> 8 | a3 << 18) & M30;
1220 r->v[3] = (a3 >> 12 | a4 << 14) & M30;
1221 r->v[4] = (a4 >> 16 | a5 << 10) & M30;
1222 r->v[5] = (a5 >> 20 | a6 << 6) & M30;
1223 r->v[6] = (a6 >> 24 | a7 << 2
1224 | a8 << 28) & M30;
1225 r->v[7] = (a8 >> 2 | a9 << 24) & M30;
1226 r->v[8] = a9 >> 6;
1227}
1228
1229static const secp256k1_modinv32_modinfo secp256k1_const_modinfo_fe = {
1230 {{-0x3D1, -4, 0, 0, 0, 0, 0, 0, 65536}},
1231 0x2DDACACFL
1232};
1233
1234static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *x) {
1235 secp256k1_fe tmp;
1236 secp256k1_modinv32_signed30 s;
1237
1238 tmp = *x;
1239 secp256k1_fe_normalize(&tmp);
1240 secp256k1_fe_to_signed30(&s, &tmp);
1241 secp256k1_modinv32(&s, &secp256k1_const_modinfo_fe);
1242 secp256k1_fe_from_signed30(r, &s);
1243
1244 VERIFY_CHECK(secp256k1_fe_normalizes_to_zero(r) == secp256k1_fe_normalizes_to_zero(&tmp));
1245}
1246
1247static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *x) {
1248 secp256k1_fe tmp;
1249 secp256k1_modinv32_signed30 s;
1250
1251 tmp = *x;
1252 secp256k1_fe_normalize_var(&tmp);
1253 secp256k1_fe_to_signed30(&s, &tmp);
1254 secp256k1_modinv32_var(&s, &secp256k1_const_modinfo_fe);
1255 secp256k1_fe_from_signed30(r, &s);
1256
1257 VERIFY_CHECK(secp256k1_fe_normalizes_to_zero(r) == secp256k1_fe_normalizes_to_zero(&tmp));
1258}
1259
1260#endif /* SECP256K1_FIELD_REPR_IMPL_H */
secp256k1_fe_normalizes_to_zero_var
static int secp256k1_fe_normalizes_to_zero_var(const secp256k1_fe *r)
Definition: field_10x26_impl.h:214
secp256k1_fe_set_int
static SECP256K1_INLINE void secp256k1_fe_set_int(secp256k1_fe *r, int a)
Definition: field_10x26_impl.h:266
secp256k1_fe_normalize_weak
static void secp256k1_fe_normalize_weak(secp256k1_fe *r)
Definition: field_10x26_impl.h:98
secp256k1_fe_sqr_inner
static SECP256K1_INLINE void secp256k1_fe_sqr_inner(uint32_t *r, const uint32_t *a)
Definition: field_10x26_impl.h:795
secp256k1_const_modinfo_fe
static const secp256k1_modinv32_modinfo secp256k1_const_modinfo_fe
Definition: field_10x26_impl.h:1229
secp256k1_fe_is_zero
static SECP256K1_INLINE int secp256k1_fe_is_zero(const secp256k1_fe *a)
Definition: field_10x26_impl.h:277
secp256k1_fe_normalize_var
static void secp256k1_fe_normalize_var(secp256k1_fe *r)
Definition: field_10x26_impl.h:129
secp256k1_fe_mul_int
static SECP256K1_INLINE void secp256k1_fe_mul_int(secp256k1_fe *r, int a)
Definition: field_10x26_impl.h:412
secp256k1_fe_mul
static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, const secp256k1_fe *SECP256K1_RESTRICT b)
Definition: field_10x26_impl.h:1070
secp256k1_fe_mul_inner
static SECP256K1_INLINE void secp256k1_fe_mul_inner(uint32_t *r, const uint32_t *a, const uint32_t *SECP256K1_RESTRICT b)
Definition: field_10x26_impl.h:465
secp256k1_fe_set_b32
static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a)
Definition: field_10x26_impl.h:324
secp256k1_fe_from_signed30
static void secp256k1_fe_from_signed30(secp256k1_fe *r, const secp256k1_modinv32_signed30 *a)
Definition: field_10x26_impl.h:1172
secp256k1_fe_storage_cmov
static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_storage *r, const secp256k1_fe_storage *a, int flag)
Definition: field_10x26_impl.h:1124
secp256k1_fe_sqr
static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a)
Definition: field_10x26_impl.h:1087
secp256k1_fe_cmov
static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const secp256k1_fe *a, int flag)
Definition: field_10x26_impl.h:1100
secp256k1_fe_normalizes_to_zero
static int secp256k1_fe_normalizes_to_zero(const secp256k1_fe *r)
Definition: field_10x26_impl.h:185
secp256k1_fe_negate
static SECP256K1_INLINE void secp256k1_fe_negate(secp256k1_fe *r, const secp256k1_fe *a, int m)
Definition: field_10x26_impl.h:390
secp256k1_fe_normalize
static void secp256k1_fe_normalize(secp256k1_fe *r)
Definition: field_10x26_impl.h:43
VERIFY_BITS
#define VERIFY_BITS(x, n)
Definition: field_10x26_impl.h:462
secp256k1_fe_is_odd
static SECP256K1_INLINE int secp256k1_fe_is_odd(const secp256k1_fe *a)
Definition: field_10x26_impl.h:286
secp256k1_fe_clear
static SECP256K1_INLINE void secp256k1_fe_clear(secp256k1_fe *a)
Definition: field_10x26_impl.h:294
secp256k1_fe_to_storage
static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp256k1_fe *a)
Definition: field_10x26_impl.h:1140
secp256k1_fe_from_storage
static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, const secp256k1_fe_storage *a)
Definition: field_10x26_impl.h:1154
secp256k1_fe_get_b32
static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a)
Convert a field element to a 32-byte big endian value.
Definition: field_10x26_impl.h:351
secp256k1_fe_add
static SECP256K1_INLINE void secp256k1_fe_add(secp256k1_fe *r, const secp256k1_fe *a)
Definition: field_10x26_impl.h:430
secp256k1_fe_to_signed30
static void secp256k1_fe_to_signed30(secp256k1_modinv32_signed30 *r, const secp256k1_fe *a)
Definition: field_10x26_impl.h:1208
secp256k1_fe_cmp_var
static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_fe *b)
Definition: field_10x26_impl.h:305
secp256k1_fe_inv
static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *x)
Definition: field_10x26_impl.h:1234
secp256k1_fe_inv_var
static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *x)
Definition: field_10x26_impl.h:1247
secp256k1_modinv32_var
static void secp256k1_modinv32_var(secp256k1_modinv32_signed30 *x, const secp256k1_modinv32_modinfo *modinfo)
secp256k1_modinv32
static void secp256k1_modinv32(secp256k1_modinv32_signed30 *x, const secp256k1_modinv32_modinfo *modinfo)
modinv32_impl.h
VG_CHECK_VERIFY
#define VG_CHECK_VERIFY(x, y)
Definition: util.h:88
VERIFY_CHECK
#define VERIFY_CHECK(cond)
Definition: util.h:68
SECP256K1_RESTRICT
#define SECP256K1_RESTRICT
Definition: util.h:160
SECP256K1_INLINE
#define SECP256K1_INLINE
Definition: secp256k1.h:127
secp256k1_fe_storage
Definition: field_10x26.h:43
secp256k1_fe_storage::n
uint32_t n[8]
Definition: field_10x26.h:44
secp256k1_fe
Definition: field_10x26.h:12
secp256k1_fe::n
uint32_t n[10]
Definition: field_10x26.h:16
secp256k1_modinv32_modinfo
Definition: modinv32.h:23
secp256k1_modinv32_signed30
Definition: modinv32.h:19
secp256k1_modinv32_signed30::v
int32_t v[9]
Definition: modinv32.h:20
Generated on Tue Jan 13 2026 20:42:10 for Bitcoin ABC by doxygen 1.9.4