1 /**********************************************************************
2 * Copyright (c) 2014 Pieter Wuille *
3 * Distributed under the MIT software license, see the accompanying *
4 * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
5 **********************************************************************/
6
7 #ifndef _SECP256K1_SCALAR_IMPL_H_
8 #define _SECP256K1_SCALAR_IMPL_H_
9
10 #include "group.h"
11 #include "scalar.h"
12
13 #if defined HAVE_CONFIG_H
14 #include "libsecp256k1-config.h"
15 #endif
16
17 #if defined(USE_SCALAR_4X64)
18 #include "scalar_4x64_impl.h"
19 #elif defined(USE_SCALAR_8X32)
20 #include "scalar_8x32_impl.h"
21 #else
22 #error "Please select scalar implementation"
23 #endif
24
25 #ifndef USE_NUM_NONE
secp256k1_scalar_get_num(secp256k1_num * r,const secp256k1_scalar * a)26 static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_scalar *a) {
27 unsigned char c[32];
28 secp256k1_scalar_get_b32(c, a);
29 secp256k1_num_set_bin(r, c, 32);
30 }
31
32 /** secp256k1 curve order, see secp256k1_ecdsa_const_order_as_fe in ecdsa_impl.h */
secp256k1_scalar_order_get_num(secp256k1_num * r)33 static void secp256k1_scalar_order_get_num(secp256k1_num *r) {
34 static const unsigned char order[32] = {
35 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
36 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
37 0xBA,0xAE,0xDC,0xE6,0xAF,0x48,0xA0,0x3B,
38 0xBF,0xD2,0x5E,0x8C,0xD0,0x36,0x41,0x41
39 };
40 secp256k1_num_set_bin(r, order, 32);
41 }
42 #endif
43
secp256k1_scalar_inverse(secp256k1_scalar * r,const secp256k1_scalar * x)44 static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k1_scalar *x) {
45 secp256k1_scalar *t;
46 int i;
47 /* First compute x ^ (2^N - 1) for some values of N. */
48 secp256k1_scalar x2, x3, x4, x6, x7, x8, x15, x30, x60, x120, x127;
49
50 secp256k1_scalar_sqr(&x2, x);
51 secp256k1_scalar_mul(&x2, &x2, x);
52
53 secp256k1_scalar_sqr(&x3, &x2);
54 secp256k1_scalar_mul(&x3, &x3, x);
55
56 secp256k1_scalar_sqr(&x4, &x3);
57 secp256k1_scalar_mul(&x4, &x4, x);
58
59 secp256k1_scalar_sqr(&x6, &x4);
60 secp256k1_scalar_sqr(&x6, &x6);
61 secp256k1_scalar_mul(&x6, &x6, &x2);
62
63 secp256k1_scalar_sqr(&x7, &x6);
64 secp256k1_scalar_mul(&x7, &x7, x);
65
66 secp256k1_scalar_sqr(&x8, &x7);
67 secp256k1_scalar_mul(&x8, &x8, x);
68
69 secp256k1_scalar_sqr(&x15, &x8);
70 for (i = 0; i < 6; i++) {
71 secp256k1_scalar_sqr(&x15, &x15);
72 }
73 secp256k1_scalar_mul(&x15, &x15, &x7);
74
75 secp256k1_scalar_sqr(&x30, &x15);
76 for (i = 0; i < 14; i++) {
77 secp256k1_scalar_sqr(&x30, &x30);
78 }
79 secp256k1_scalar_mul(&x30, &x30, &x15);
80
81 secp256k1_scalar_sqr(&x60, &x30);
82 for (i = 0; i < 29; i++) {
83 secp256k1_scalar_sqr(&x60, &x60);
84 }
85 secp256k1_scalar_mul(&x60, &x60, &x30);
86
87 secp256k1_scalar_sqr(&x120, &x60);
88 for (i = 0; i < 59; i++) {
89 secp256k1_scalar_sqr(&x120, &x120);
90 }
91 secp256k1_scalar_mul(&x120, &x120, &x60);
92
93 secp256k1_scalar_sqr(&x127, &x120);
94 for (i = 0; i < 6; i++) {
95 secp256k1_scalar_sqr(&x127, &x127);
96 }
97 secp256k1_scalar_mul(&x127, &x127, &x7);
98
99 /* Then accumulate the final result (t starts at x127). */
100 t = &x127;
101 for (i = 0; i < 2; i++) { /* 0 */
102 secp256k1_scalar_sqr(t, t);
103 }
104 secp256k1_scalar_mul(t, t, x); /* 1 */
105 for (i = 0; i < 4; i++) { /* 0 */
106 secp256k1_scalar_sqr(t, t);
107 }
108 secp256k1_scalar_mul(t, t, &x3); /* 111 */
109 for (i = 0; i < 2; i++) { /* 0 */
110 secp256k1_scalar_sqr(t, t);
111 }
112 secp256k1_scalar_mul(t, t, x); /* 1 */
113 for (i = 0; i < 2; i++) { /* 0 */
114 secp256k1_scalar_sqr(t, t);
115 }
116 secp256k1_scalar_mul(t, t, x); /* 1 */
117 for (i = 0; i < 2; i++) { /* 0 */
118 secp256k1_scalar_sqr(t, t);
119 }
120 secp256k1_scalar_mul(t, t, x); /* 1 */
121 for (i = 0; i < 4; i++) { /* 0 */
122 secp256k1_scalar_sqr(t, t);
123 }
124 secp256k1_scalar_mul(t, t, &x3); /* 111 */
125 for (i = 0; i < 3; i++) { /* 0 */
126 secp256k1_scalar_sqr(t, t);
127 }
128 secp256k1_scalar_mul(t, t, &x2); /* 11 */
129 for (i = 0; i < 4; i++) { /* 0 */
130 secp256k1_scalar_sqr(t, t);
131 }
132 secp256k1_scalar_mul(t, t, &x3); /* 111 */
133 for (i = 0; i < 5; i++) { /* 00 */
134 secp256k1_scalar_sqr(t, t);
135 }
136 secp256k1_scalar_mul(t, t, &x3); /* 111 */
137 for (i = 0; i < 4; i++) { /* 00 */
138 secp256k1_scalar_sqr(t, t);
139 }
140 secp256k1_scalar_mul(t, t, &x2); /* 11 */
141 for (i = 0; i < 2; i++) { /* 0 */
142 secp256k1_scalar_sqr(t, t);
143 }
144 secp256k1_scalar_mul(t, t, x); /* 1 */
145 for (i = 0; i < 2; i++) { /* 0 */
146 secp256k1_scalar_sqr(t, t);
147 }
148 secp256k1_scalar_mul(t, t, x); /* 1 */
149 for (i = 0; i < 5; i++) { /* 0 */
150 secp256k1_scalar_sqr(t, t);
151 }
152 secp256k1_scalar_mul(t, t, &x4); /* 1111 */
153 for (i = 0; i < 2; i++) { /* 0 */
154 secp256k1_scalar_sqr(t, t);
155 }
156 secp256k1_scalar_mul(t, t, x); /* 1 */
157 for (i = 0; i < 3; i++) { /* 00 */
158 secp256k1_scalar_sqr(t, t);
159 }
160 secp256k1_scalar_mul(t, t, x); /* 1 */
161 for (i = 0; i < 4; i++) { /* 000 */
162 secp256k1_scalar_sqr(t, t);
163 }
164 secp256k1_scalar_mul(t, t, x); /* 1 */
165 for (i = 0; i < 2; i++) { /* 0 */
166 secp256k1_scalar_sqr(t, t);
167 }
168 secp256k1_scalar_mul(t, t, x); /* 1 */
169 for (i = 0; i < 10; i++) { /* 0000000 */
170 secp256k1_scalar_sqr(t, t);
171 }
172 secp256k1_scalar_mul(t, t, &x3); /* 111 */
173 for (i = 0; i < 4; i++) { /* 0 */
174 secp256k1_scalar_sqr(t, t);
175 }
176 secp256k1_scalar_mul(t, t, &x3); /* 111 */
177 for (i = 0; i < 9; i++) { /* 0 */
178 secp256k1_scalar_sqr(t, t);
179 }
180 secp256k1_scalar_mul(t, t, &x8); /* 11111111 */
181 for (i = 0; i < 2; i++) { /* 0 */
182 secp256k1_scalar_sqr(t, t);
183 }
184 secp256k1_scalar_mul(t, t, x); /* 1 */
185 for (i = 0; i < 3; i++) { /* 00 */
186 secp256k1_scalar_sqr(t, t);
187 }
188 secp256k1_scalar_mul(t, t, x); /* 1 */
189 for (i = 0; i < 3; i++) { /* 00 */
190 secp256k1_scalar_sqr(t, t);
191 }
192 secp256k1_scalar_mul(t, t, x); /* 1 */
193 for (i = 0; i < 5; i++) { /* 0 */
194 secp256k1_scalar_sqr(t, t);
195 }
196 secp256k1_scalar_mul(t, t, &x4); /* 1111 */
197 for (i = 0; i < 2; i++) { /* 0 */
198 secp256k1_scalar_sqr(t, t);
199 }
200 secp256k1_scalar_mul(t, t, x); /* 1 */
201 for (i = 0; i < 5; i++) { /* 000 */
202 secp256k1_scalar_sqr(t, t);
203 }
204 secp256k1_scalar_mul(t, t, &x2); /* 11 */
205 for (i = 0; i < 4; i++) { /* 00 */
206 secp256k1_scalar_sqr(t, t);
207 }
208 secp256k1_scalar_mul(t, t, &x2); /* 11 */
209 for (i = 0; i < 2; i++) { /* 0 */
210 secp256k1_scalar_sqr(t, t);
211 }
212 secp256k1_scalar_mul(t, t, x); /* 1 */
213 for (i = 0; i < 8; i++) { /* 000000 */
214 secp256k1_scalar_sqr(t, t);
215 }
216 secp256k1_scalar_mul(t, t, &x2); /* 11 */
217 for (i = 0; i < 3; i++) { /* 0 */
218 secp256k1_scalar_sqr(t, t);
219 }
220 secp256k1_scalar_mul(t, t, &x2); /* 11 */
221 for (i = 0; i < 3; i++) { /* 00 */
222 secp256k1_scalar_sqr(t, t);
223 }
224 secp256k1_scalar_mul(t, t, x); /* 1 */
225 for (i = 0; i < 6; i++) { /* 00000 */
226 secp256k1_scalar_sqr(t, t);
227 }
228 secp256k1_scalar_mul(t, t, x); /* 1 */
229 for (i = 0; i < 8; i++) { /* 00 */
230 secp256k1_scalar_sqr(t, t);
231 }
232 secp256k1_scalar_mul(r, t, &x6); /* 111111 */
233 }
234
secp256k1_scalar_is_even(const secp256k1_scalar * a)235 SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_scalar *a) {
236 /* d[0] is present and is the lowest word for all representations */
237 return !(a->d[0] & 1);
238 }
239
secp256k1_scalar_inverse_var(secp256k1_scalar * r,const secp256k1_scalar * x)240 static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp256k1_scalar *x) {
241 #if defined(USE_SCALAR_INV_BUILTIN)
242 secp256k1_scalar_inverse(r, x);
243 #elif defined(USE_SCALAR_INV_NUM)
244 unsigned char b[32];
245 secp256k1_num n, m;
246 secp256k1_scalar t = *x;
247 secp256k1_scalar_get_b32(b, &t);
248 secp256k1_num_set_bin(&n, b, 32);
249 secp256k1_scalar_order_get_num(&m);
250 secp256k1_num_mod_inverse(&n, &n, &m);
251 secp256k1_num_get_bin(b, 32, &n);
252 secp256k1_scalar_set_b32(r, b, NULL);
253 /* Verify that the inverse was computed correctly, without GMP code. */
254 secp256k1_scalar_mul(&t, &t, r);
255 CHECK(secp256k1_scalar_is_one(&t));
256 #else
257 #error "Please select scalar inverse implementation"
258 #endif
259 }
260
261 #ifdef USE_ENDOMORPHISM
262 /**
263 * The Secp256k1 curve has an endomorphism, where lambda * (x, y) = (beta * x, y), where
264 * lambda is {0x53,0x63,0xad,0x4c,0xc0,0x5c,0x30,0xe0,0xa5,0x26,0x1c,0x02,0x88,0x12,0x64,0x5a,
265 * 0x12,0x2e,0x22,0xea,0x20,0x81,0x66,0x78,0xdf,0x02,0x96,0x7c,0x1b,0x23,0xbd,0x72}
266 *
267 * "Guide to Elliptic Curve Cryptography" (Hankerson, Menezes, Vanstone) gives an algorithm
268 * (algorithm 3.74) to find k1 and k2 given k, such that k1 + k2 * lambda == k mod n, and k1
269 * and k2 have a small size.
270 * It relies on constants a1, b1, a2, b2. These constants for the value of lambda above are:
271 *
272 * - a1 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
273 * - b1 = -{0xe4,0x43,0x7e,0xd6,0x01,0x0e,0x88,0x28,0x6f,0x54,0x7f,0xa9,0x0a,0xbf,0xe4,0xc3}
274 * - a2 = {0x01,0x14,0xca,0x50,0xf7,0xa8,0xe2,0xf3,0xf6,0x57,0xc1,0x10,0x8d,0x9d,0x44,0xcf,0xd8}
275 * - b2 = {0x30,0x86,0xd2,0x21,0xa7,0xd4,0x6b,0xcd,0xe8,0x6c,0x90,0xe4,0x92,0x84,0xeb,0x15}
276 *
277 * The algorithm then computes c1 = round(b1 * k / n) and c2 = round(b2 * k / n), and gives
278 * k1 = k - (c1*a1 + c2*a2) and k2 = -(c1*b1 + c2*b2). Instead, we use modular arithmetic, and
279 * compute k1 as k - k2 * lambda, avoiding the need for constants a1 and a2.
280 *
281 * g1, g2 are precomputed constants used to replace division with a rounded multiplication
282 * when decomposing the scalar for an endomorphism-based point multiplication.
283 *
284 * The possibility of using precomputed estimates is mentioned in "Guide to Elliptic Curve
285 * Cryptography" (Hankerson, Menezes, Vanstone) in section 3.5.
286 *
287 * The derivation is described in the paper "Efficient Software Implementation of Public-Key
288 * Cryptography on Sensor Networks Using the MSP430X Microcontroller" (Gouvea, Oliveira, Lopez),
289 * Section 4.3 (here we use a somewhat higher-precision estimate):
290 * d = a1*b2 - b1*a2
291 * g1 = round((2^272)*b2/d)
292 * g2 = round((2^272)*b1/d)
293 *
294 * (Note that 'd' is also equal to the curve order here because [a1,b1] and [a2,b2] are found
295 * as outputs of the Extended Euclidean Algorithm on inputs 'order' and 'lambda').
296 *
297 * The function below splits a in r1 and r2, such that r1 + lambda * r2 == a (mod order).
298 */
299
secp256k1_scalar_split_lambda(secp256k1_scalar * r1,secp256k1_scalar * r2,const secp256k1_scalar * a)300 static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a) {
301 secp256k1_scalar c1, c2;
302 static const secp256k1_scalar minus_lambda = SECP256K1_SCALAR_CONST(
303 0xAC9C52B3UL, 0x3FA3CF1FUL, 0x5AD9E3FDUL, 0x77ED9BA4UL,
304 0xA880B9FCUL, 0x8EC739C2UL, 0xE0CFC810UL, 0xB51283CFUL
305 );
306 static const secp256k1_scalar minus_b1 = SECP256K1_SCALAR_CONST(
307 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,
308 0xE4437ED6UL, 0x010E8828UL, 0x6F547FA9UL, 0x0ABFE4C3UL
309 );
310 static const secp256k1_scalar minus_b2 = SECP256K1_SCALAR_CONST(
311 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFFUL, 0xFFFFFFFEUL,
312 0x8A280AC5UL, 0x0774346DUL, 0xD765CDA8UL, 0x3DB1562CUL
313 );
314 static const secp256k1_scalar g1 = SECP256K1_SCALAR_CONST(
315 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00003086UL,
316 0xD221A7D4UL, 0x6BCDE86CUL, 0x90E49284UL, 0xEB153DABUL
317 );
318 static const secp256k1_scalar g2 = SECP256K1_SCALAR_CONST(
319 0x00000000UL, 0x00000000UL, 0x00000000UL, 0x0000E443UL,
320 0x7ED6010EUL, 0x88286F54UL, 0x7FA90ABFUL, 0xE4C42212UL
321 );
322 VERIFY_CHECK(r1 != a);
323 VERIFY_CHECK(r2 != a);
324 /* these _var calls are constant time since the shift amount is constant */
325 secp256k1_scalar_mul_shift_var(&c1, a, &g1, 272);
326 secp256k1_scalar_mul_shift_var(&c2, a, &g2, 272);
327 secp256k1_scalar_mul(&c1, &c1, &minus_b1);
328 secp256k1_scalar_mul(&c2, &c2, &minus_b2);
329 secp256k1_scalar_add(r2, &c1, &c2);
330 secp256k1_scalar_mul(r1, r2, &minus_lambda);
331 secp256k1_scalar_add(r1, r1, a);
332 }
333 #endif
334
335 #endif
336