Added new 64-bit implementations of Curve25519 and P-256.
[BearSSL] / src / ec / ec_prime_i15.c
1 /*
2 * Copyright (c) 2017 Thomas Pornin <pornin@bolet.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25 #include "inner.h"
26
27 /*
28 * Parameters for supported curves:
29 * - field modulus p
30 * - R^2 mod p (R = 2^(15k) for the smallest k such that R >= p)
31 * - b*R mod p (b is the second curve equation parameter)
32 */
33
34 static const uint16_t P256_P[] = {
35 0x0111,
36 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x003F, 0x0000,
37 0x0000, 0x0000, 0x0000, 0x0000, 0x1000, 0x0000, 0x4000, 0x7FFF,
38 0x7FFF, 0x0001
39 };
40
41 static const uint16_t P256_R2[] = {
42 0x0111,
43 0x0000, 0x6000, 0x0000, 0x0000, 0x0000, 0x0000, 0x7FFC, 0x7FFF,
44 0x7FBF, 0x7FFF, 0x7FBF, 0x7FFF, 0x7FFF, 0x7FFF, 0x77FF, 0x7FFF,
45 0x4FFF, 0x0000
46 };
47
48 static const uint16_t P256_B[] = {
49 0x0111,
50 0x770C, 0x5EEF, 0x29C4, 0x3EC4, 0x6273, 0x0486, 0x4543, 0x3993,
51 0x3C01, 0x6B56, 0x212E, 0x57EE, 0x4882, 0x204B, 0x7483, 0x3C16,
52 0x0187, 0x0000
53 };
54
55 static const uint16_t P384_P[] = {
56 0x0199,
57 0x7FFF, 0x7FFF, 0x0003, 0x0000, 0x0000, 0x0000, 0x7FC0, 0x7FFF,
58 0x7EFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
59 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
60 0x7FFF, 0x01FF
61 };
62
63 static const uint16_t P384_R2[] = {
64 0x0199,
65 0x1000, 0x0000, 0x0000, 0x7FFF, 0x7FFF, 0x0001, 0x0000, 0x0010,
66 0x0000, 0x0000, 0x0000, 0x7F00, 0x7FFF, 0x01FF, 0x0000, 0x1000,
67 0x0000, 0x2000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
68 0x0000, 0x0000
69 };
70
71 static const uint16_t P384_B[] = {
72 0x0199,
73 0x7333, 0x2096, 0x70D1, 0x2310, 0x3020, 0x6197, 0x1464, 0x35BB,
74 0x70CA, 0x0117, 0x1920, 0x4136, 0x5FC8, 0x5713, 0x4938, 0x7DD2,
75 0x4DD2, 0x4A71, 0x0220, 0x683E, 0x2C87, 0x4DB1, 0x7BFF, 0x6C09,
76 0x0452, 0x0084
77 };
78
79 static const uint16_t P521_P[] = {
80 0x022B,
81 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
82 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
83 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
84 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF,
85 0x7FFF, 0x7FFF, 0x07FF
86 };
87
88 static const uint16_t P521_R2[] = {
89 0x022B,
90 0x0100, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
91 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
92 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
93 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
94 0x0000, 0x0000, 0x0000
95 };
96
97 static const uint16_t P521_B[] = {
98 0x022B,
99 0x7002, 0x6A07, 0x751A, 0x228F, 0x71EF, 0x5869, 0x20F4, 0x1EFC,
100 0x7357, 0x37E0, 0x4EEC, 0x605E, 0x1652, 0x26F6, 0x31FA, 0x4A8F,
101 0x6193, 0x3C2A, 0x3C42, 0x48C7, 0x3489, 0x6771, 0x4C57, 0x5CCD,
102 0x2725, 0x545B, 0x503B, 0x5B42, 0x21A0, 0x2534, 0x687E, 0x70E4,
103 0x1618, 0x27D7, 0x0465
104 };
105
106 typedef struct {
107 const uint16_t *p;
108 const uint16_t *b;
109 const uint16_t *R2;
110 uint16_t p0i;
111 size_t point_len;
112 } curve_params;
113
114 static inline const curve_params *
115 id_to_curve(int curve)
116 {
117 static const curve_params pp[] = {
118 { P256_P, P256_B, P256_R2, 0x0001, 65 },
119 { P384_P, P384_B, P384_R2, 0x0001, 97 },
120 { P521_P, P521_B, P521_R2, 0x0001, 133 }
121 };
122
123 return &pp[curve - BR_EC_secp256r1];
124 }
125
126 #define I15_LEN ((BR_MAX_EC_SIZE + 29) / 15)
127
128 /*
129 * Type for a point in Jacobian coordinates:
130 * -- three values, x, y and z, in Montgomery representation
131 * -- affine coordinates are X = x / z^2 and Y = y / z^3
132 * -- for the point at infinity, z = 0
133 */
134 typedef struct {
135 uint16_t c[3][I15_LEN];
136 } jacobian;
137
138 /*
139 * We use a custom interpreter that uses a dozen registers, and
140 * only six operations:
141 * MSET(d, a) copy a into d
142 * MADD(d, a) d = d+a (modular)
143 * MSUB(d, a) d = d-a (modular)
144 * MMUL(d, a, b) d = a*b (Montgomery multiplication)
145 * MINV(d, a, b) invert d modulo p; a and b are used as scratch registers
146 * MTZ(d) clear return value if d = 0
147 * Destination of MMUL (d) must be distinct from operands (a and b).
148 * There is no such constraint for MSUB and MADD.
149 *
150 * Registers include the operand coordinates, and temporaries.
151 */
152 #define MSET(d, a) (0x0000 + ((d) << 8) + ((a) << 4))
153 #define MADD(d, a) (0x1000 + ((d) << 8) + ((a) << 4))
154 #define MSUB(d, a) (0x2000 + ((d) << 8) + ((a) << 4))
155 #define MMUL(d, a, b) (0x3000 + ((d) << 8) + ((a) << 4) + (b))
156 #define MINV(d, a, b) (0x4000 + ((d) << 8) + ((a) << 4) + (b))
157 #define MTZ(d) (0x5000 + ((d) << 8))
158 #define ENDCODE 0
159
160 /*
161 * Registers for the input operands.
162 */
163 #define P1x 0
164 #define P1y 1
165 #define P1z 2
166 #define P2x 3
167 #define P2y 4
168 #define P2z 5
169
170 /*
171 * Alternate names for the first input operand.
172 */
173 #define Px 0
174 #define Py 1
175 #define Pz 2
176
177 /*
178 * Temporaries.
179 */
180 #define t1 6
181 #define t2 7
182 #define t3 8
183 #define t4 9
184 #define t5 10
185 #define t6 11
186 #define t7 12
187
188 /*
189 * Extra scratch registers available when there is no second operand (e.g.
190 * for "double" and "affine").
191 */
192 #define t8 3
193 #define t9 4
194 #define t10 5
195
196 /*
197 * Doubling formulas are:
198 *
199 * s = 4*x*y^2
200 * m = 3*(x + z^2)*(x - z^2)
201 * x' = m^2 - 2*s
202 * y' = m*(s - x') - 8*y^4
203 * z' = 2*y*z
204 *
205 * If y = 0 (P has order 2) then this yields infinity (z' = 0), as it
206 * should. This case should not happen anyway, because our curves have
207 * prime order, and thus do not contain any point of order 2.
208 *
209 * If P is infinity (z = 0), then again the formulas yield infinity,
210 * which is correct. Thus, this code works for all points.
211 *
212 * Cost: 8 multiplications
213 */
214 static const uint16_t code_double[] = {
215 /*
216 * Compute z^2 (in t1).
217 */
218 MMUL(t1, Pz, Pz),
219
220 /*
221 * Compute x-z^2 (in t2) and then x+z^2 (in t1).
222 */
223 MSET(t2, Px),
224 MSUB(t2, t1),
225 MADD(t1, Px),
226
227 /*
228 * Compute m = 3*(x+z^2)*(x-z^2) (in t1).
229 */
230 MMUL(t3, t1, t2),
231 MSET(t1, t3),
232 MADD(t1, t3),
233 MADD(t1, t3),
234
235 /*
236 * Compute s = 4*x*y^2 (in t2) and 2*y^2 (in t3).
237 */
238 MMUL(t3, Py, Py),
239 MADD(t3, t3),
240 MMUL(t2, Px, t3),
241 MADD(t2, t2),
242
243 /*
244 * Compute x' = m^2 - 2*s.
245 */
246 MMUL(Px, t1, t1),
247 MSUB(Px, t2),
248 MSUB(Px, t2),
249
250 /*
251 * Compute z' = 2*y*z.
252 */
253 MMUL(t4, Py, Pz),
254 MSET(Pz, t4),
255 MADD(Pz, t4),
256
257 /*
258 * Compute y' = m*(s - x') - 8*y^4. Note that we already have
259 * 2*y^2 in t3.
260 */
261 MSUB(t2, Px),
262 MMUL(Py, t1, t2),
263 MMUL(t4, t3, t3),
264 MSUB(Py, t4),
265 MSUB(Py, t4),
266
267 ENDCODE
268 };
269
270 /*
271 * Addtions formulas are:
272 *
273 * u1 = x1 * z2^2
274 * u2 = x2 * z1^2
275 * s1 = y1 * z2^3
276 * s2 = y2 * z1^3
277 * h = u2 - u1
278 * r = s2 - s1
279 * x3 = r^2 - h^3 - 2 * u1 * h^2
280 * y3 = r * (u1 * h^2 - x3) - s1 * h^3
281 * z3 = h * z1 * z2
282 *
283 * If both P1 and P2 are infinity, then z1 == 0 and z2 == 0, implying that
284 * z3 == 0, so the result is correct.
285 * If either of P1 or P2 is infinity, but not both, then z3 == 0, which is
286 * not correct.
287 * h == 0 only if u1 == u2; this happens in two cases:
288 * -- if s1 == s2 then P1 and/or P2 is infinity, or P1 == P2
289 * -- if s1 != s2 then P1 + P2 == infinity (but neither P1 or P2 is infinity)
290 *
291 * Thus, the following situations are not handled correctly:
292 * -- P1 = 0 and P2 != 0
293 * -- P1 != 0 and P2 = 0
294 * -- P1 = P2
295 * All other cases are properly computed. However, even in "incorrect"
296 * situations, the three coordinates still are properly formed field
297 * elements.
298 *
299 * The returned flag is cleared if r == 0. This happens in the following
300 * cases:
301 * -- Both points are on the same horizontal line (same Y coordinate).
302 * -- Both points are infinity.
303 * -- One point is infinity and the other is on line Y = 0.
304 * The third case cannot happen with our curves (there is no valid point
305 * on line Y = 0 since that would be a point of order 2). If the two
306 * source points are non-infinity, then remains only the case where the
307 * two points are on the same horizontal line.
308 *
309 * This allows us to detect the "P1 == P2" case, assuming that P1 != 0 and
310 * P2 != 0:
311 * -- If the returned value is not the point at infinity, then it was properly
312 * computed.
313 * -- Otherwise, if the returned flag is 1, then P1+P2 = 0, and the result
314 * is indeed the point at infinity.
315 * -- Otherwise (result is infinity, flag is 0), then P1 = P2 and we should
316 * use the 'double' code.
317 *
318 * Cost: 16 multiplications
319 */
320 static const uint16_t code_add[] = {
321 /*
322 * Compute u1 = x1*z2^2 (in t1) and s1 = y1*z2^3 (in t3).
323 */
324 MMUL(t3, P2z, P2z),
325 MMUL(t1, P1x, t3),
326 MMUL(t4, P2z, t3),
327 MMUL(t3, P1y, t4),
328
329 /*
330 * Compute u2 = x2*z1^2 (in t2) and s2 = y2*z1^3 (in t4).
331 */
332 MMUL(t4, P1z, P1z),
333 MMUL(t2, P2x, t4),
334 MMUL(t5, P1z, t4),
335 MMUL(t4, P2y, t5),
336
337 /*
338 * Compute h = u2 - u1 (in t2) and r = s2 - s1 (in t4).
339 */
340 MSUB(t2, t1),
341 MSUB(t4, t3),
342
343 /*
344 * Report cases where r = 0 through the returned flag.
345 */
346 MTZ(t4),
347
348 /*
349 * Compute u1*h^2 (in t6) and h^3 (in t5).
350 */
351 MMUL(t7, t2, t2),
352 MMUL(t6, t1, t7),
353 MMUL(t5, t7, t2),
354
355 /*
356 * Compute x3 = r^2 - h^3 - 2*u1*h^2.
357 * t1 and t7 can be used as scratch registers.
358 */
359 MMUL(P1x, t4, t4),
360 MSUB(P1x, t5),
361 MSUB(P1x, t6),
362 MSUB(P1x, t6),
363
364 /*
365 * Compute y3 = r*(u1*h^2 - x3) - s1*h^3.
366 */
367 MSUB(t6, P1x),
368 MMUL(P1y, t4, t6),
369 MMUL(t1, t5, t3),
370 MSUB(P1y, t1),
371
372 /*
373 * Compute z3 = h*z1*z2.
374 */
375 MMUL(t1, P1z, P2z),
376 MMUL(P1z, t1, t2),
377
378 ENDCODE
379 };
380
381 /*
382 * Check that the point is on the curve. This code snippet assumes the
383 * following conventions:
384 * -- Coordinates x and y have been freshly decoded in P1 (but not
385 * converted to Montgomery coordinates yet).
386 * -- P2x, P2y and P2z are set to, respectively, R^2, b*R and 1.
387 */
388 static const uint16_t code_check[] = {
389
390 /* Convert x and y to Montgomery representation. */
391 MMUL(t1, P1x, P2x),
392 MMUL(t2, P1y, P2x),
393 MSET(P1x, t1),
394 MSET(P1y, t2),
395
396 /* Compute x^3 in t1. */
397 MMUL(t2, P1x, P1x),
398 MMUL(t1, P1x, t2),
399
400 /* Subtract 3*x from t1. */
401 MSUB(t1, P1x),
402 MSUB(t1, P1x),
403 MSUB(t1, P1x),
404
405 /* Add b. */
406 MADD(t1, P2y),
407
408 /* Compute y^2 in t2. */
409 MMUL(t2, P1y, P1y),
410
411 /* Compare y^2 with x^3 - 3*x + b; they must match. */
412 MSUB(t1, t2),
413 MTZ(t1),
414
415 /* Set z to 1 (in Montgomery representation). */
416 MMUL(P1z, P2x, P2z),
417
418 ENDCODE
419 };
420
421 /*
422 * Conversion back to affine coordinates. This code snippet assumes that
423 * the z coordinate of P2 is set to 1 (not in Montgomery representation).
424 */
425 static const uint16_t code_affine[] = {
426
427 /* Save z*R in t1. */
428 MSET(t1, P1z),
429
430 /* Compute z^3 in t2. */
431 MMUL(t2, P1z, P1z),
432 MMUL(t3, P1z, t2),
433 MMUL(t2, t3, P2z),
434
435 /* Invert to (1/z^3) in t2. */
436 MINV(t2, t3, t4),
437
438 /* Compute y. */
439 MSET(t3, P1y),
440 MMUL(P1y, t2, t3),
441
442 /* Compute (1/z^2) in t3. */
443 MMUL(t3, t2, t1),
444
445 /* Compute x. */
446 MSET(t2, P1x),
447 MMUL(P1x, t2, t3),
448
449 ENDCODE
450 };
451
452 static uint32_t
453 run_code(jacobian *P1, const jacobian *P2,
454 const curve_params *cc, const uint16_t *code)
455 {
456 uint32_t r;
457 uint16_t t[13][I15_LEN];
458 size_t u;
459
460 r = 1;
461
462 /*
463 * Copy the two operands in the dedicated registers.
464 */
465 memcpy(t[P1x], P1->c, 3 * I15_LEN * sizeof(uint16_t));
466 memcpy(t[P2x], P2->c, 3 * I15_LEN * sizeof(uint16_t));
467
468 /*
469 * Run formulas.
470 */
471 for (u = 0;; u ++) {
472 unsigned op, d, a, b;
473
474 op = code[u];
475 if (op == 0) {
476 break;
477 }
478 d = (op >> 8) & 0x0F;
479 a = (op >> 4) & 0x0F;
480 b = op & 0x0F;
481 op >>= 12;
482 switch (op) {
483 uint32_t ctl;
484 size_t plen;
485 unsigned char tp[(BR_MAX_EC_SIZE + 7) >> 3];
486
487 case 0:
488 memcpy(t[d], t[a], I15_LEN * sizeof(uint16_t));
489 break;
490 case 1:
491 ctl = br_i15_add(t[d], t[a], 1);
492 ctl |= NOT(br_i15_sub(t[d], cc->p, 0));
493 br_i15_sub(t[d], cc->p, ctl);
494 break;
495 case 2:
496 br_i15_add(t[d], cc->p, br_i15_sub(t[d], t[a], 1));
497 break;
498 case 3:
499 br_i15_montymul(t[d], t[a], t[b], cc->p, cc->p0i);
500 break;
501 case 4:
502 plen = (cc->p[0] - (cc->p[0] >> 4) + 7) >> 3;
503 br_i15_encode(tp, plen, cc->p);
504 tp[plen - 1] -= 2;
505 br_i15_modpow(t[d], tp, plen,
506 cc->p, cc->p0i, t[a], t[b]);
507 break;
508 default:
509 r &= ~br_i15_iszero(t[d]);
510 break;
511 }
512 }
513
514 /*
515 * Copy back result.
516 */
517 memcpy(P1->c, t[P1x], 3 * I15_LEN * sizeof(uint16_t));
518 return r;
519 }
520
521 static void
522 set_one(uint16_t *x, const uint16_t *p)
523 {
524 size_t plen;
525
526 plen = (p[0] + 31) >> 4;
527 memset(x, 0, plen * sizeof *x);
528 x[0] = p[0];
529 x[1] = 0x0001;
530 }
531
532 static void
533 point_zero(jacobian *P, const curve_params *cc)
534 {
535 memset(P, 0, sizeof *P);
536 P->c[0][0] = P->c[1][0] = P->c[2][0] = cc->p[0];
537 }
538
539 static inline void
540 point_double(jacobian *P, const curve_params *cc)
541 {
542 run_code(P, P, cc, code_double);
543 }
544
545 static inline uint32_t
546 point_add(jacobian *P1, const jacobian *P2, const curve_params *cc)
547 {
548 return run_code(P1, P2, cc, code_add);
549 }
550
551 static void
552 point_mul(jacobian *P, const unsigned char *x, size_t xlen,
553 const curve_params *cc)
554 {
555 /*
556 * We do a simple double-and-add ladder with a 2-bit window
557 * to make only one add every two doublings. We thus first
558 * precompute 2P and 3P in some local buffers.
559 *
560 * We always perform two doublings and one addition; the
561 * addition is with P, 2P and 3P and is done in a temporary
562 * array.
563 *
564 * The addition code cannot handle cases where one of the
565 * operands is infinity, which is the case at the start of the
566 * ladder. We therefore need to maintain a flag that controls
567 * this situation.
568 */
569 uint32_t qz;
570 jacobian P2, P3, Q, T, U;
571
572 memcpy(&P2, P, sizeof P2);
573 point_double(&P2, cc);
574 memcpy(&P3, P, sizeof P3);
575 point_add(&P3, &P2, cc);
576
577 point_zero(&Q, cc);
578 qz = 1;
579 while (xlen -- > 0) {
580 int k;
581
582 for (k = 6; k >= 0; k -= 2) {
583 uint32_t bits;
584 uint32_t bnz;
585
586 point_double(&Q, cc);
587 point_double(&Q, cc);
588 memcpy(&T, P, sizeof T);
589 memcpy(&U, &Q, sizeof U);
590 bits = (*x >> k) & (uint32_t)3;
591 bnz = NEQ(bits, 0);
592 CCOPY(EQ(bits, 2), &T, &P2, sizeof T);
593 CCOPY(EQ(bits, 3), &T, &P3, sizeof T);
594 point_add(&U, &T, cc);
595 CCOPY(bnz & qz, &Q, &T, sizeof Q);
596 CCOPY(bnz & ~qz, &Q, &U, sizeof Q);
597 qz &= ~bnz;
598 }
599 x ++;
600 }
601 memcpy(P, &Q, sizeof Q);
602 }
603
604 /*
605 * Decode point into Jacobian coordinates. This function does not support
606 * the point at infinity. If the point is invalid then this returns 0, but
607 * the coordinates are still set to properly formed field elements.
608 */
609 static uint32_t
610 point_decode(jacobian *P, const void *src, size_t len, const curve_params *cc)
611 {
612 /*
613 * Points must use uncompressed format:
614 * -- first byte is 0x04;
615 * -- coordinates X and Y use unsigned big-endian, with the same
616 * length as the field modulus.
617 *
618 * We don't support hybrid format (uncompressed, but first byte
619 * has value 0x06 or 0x07, depending on the least significant bit
620 * of Y) because it is rather useless, and explicitly forbidden
621 * by PKIX (RFC 5480, section 2.2).
622 *
623 * We don't support compressed format either, because it is not
624 * much used in practice (there are or were patent-related
625 * concerns about point compression, which explains the lack of
626 * generalised support). Also, point compression support would
627 * need a bit more code.
628 */
629 const unsigned char *buf;
630 size_t plen, zlen;
631 uint32_t r;
632 jacobian Q;
633
634 buf = src;
635 point_zero(P, cc);
636 plen = (cc->p[0] - (cc->p[0] >> 4) + 7) >> 3;
637 if (len != 1 + (plen << 1)) {
638 return 0;
639 }
640 r = br_i15_decode_mod(P->c[0], buf + 1, plen, cc->p);
641 r &= br_i15_decode_mod(P->c[1], buf + 1 + plen, plen, cc->p);
642
643 /*
644 * Check first byte.
645 */
646 r &= EQ(buf[0], 0x04);
647 /* obsolete
648 r &= EQ(buf[0], 0x04) | (EQ(buf[0] & 0xFE, 0x06)
649 & ~(uint32_t)(buf[0] ^ buf[plen << 1]));
650 */
651
652 /*
653 * Convert coordinates and check that the point is valid.
654 */
655 zlen = ((cc->p[0] + 31) >> 4) * sizeof(uint16_t);
656 memcpy(Q.c[0], cc->R2, zlen);
657 memcpy(Q.c[1], cc->b, zlen);
658 set_one(Q.c[2], cc->p);
659 r &= ~run_code(P, &Q, cc, code_check);
660 return r;
661 }
662
663 /*
664 * Encode a point. This method assumes that the point is correct and is
665 * not the point at infinity. Encoded size is always 1+2*plen, where
666 * plen is the field modulus length, in bytes.
667 */
668 static void
669 point_encode(void *dst, const jacobian *P, const curve_params *cc)
670 {
671 unsigned char *buf;
672 size_t plen;
673 jacobian Q, T;
674
675 buf = dst;
676 plen = (cc->p[0] - (cc->p[0] >> 4) + 7) >> 3;
677 buf[0] = 0x04;
678 memcpy(&Q, P, sizeof *P);
679 set_one(T.c[2], cc->p);
680 run_code(&Q, &T, cc, code_affine);
681 br_i15_encode(buf + 1, plen, Q.c[0]);
682 br_i15_encode(buf + 1 + plen, plen, Q.c[1]);
683 }
684
685 static const br_ec_curve_def *
686 id_to_curve_def(int curve)
687 {
688 switch (curve) {
689 case BR_EC_secp256r1:
690 return &br_secp256r1;
691 case BR_EC_secp384r1:
692 return &br_secp384r1;
693 case BR_EC_secp521r1:
694 return &br_secp521r1;
695 }
696 return NULL;
697 }
698
699 static const unsigned char *
700 api_generator(int curve, size_t *len)
701 {
702 const br_ec_curve_def *cd;
703
704 cd = id_to_curve_def(curve);
705 *len = cd->generator_len;
706 return cd->generator;
707 }
708
709 static const unsigned char *
710 api_order(int curve, size_t *len)
711 {
712 const br_ec_curve_def *cd;
713
714 cd = id_to_curve_def(curve);
715 *len = cd->order_len;
716 return cd->order;
717 }
718
719 static size_t
720 api_xoff(int curve, size_t *len)
721 {
722 api_generator(curve, len);
723 *len >>= 1;
724 return 1;
725 }
726
727 static uint32_t
728 api_mul(unsigned char *G, size_t Glen,
729 const unsigned char *x, size_t xlen, int curve)
730 {
731 uint32_t r;
732 const curve_params *cc;
733 jacobian P;
734
735 cc = id_to_curve(curve);
736 r = point_decode(&P, G, Glen, cc);
737 point_mul(&P, x, xlen, cc);
738 if (Glen == cc->point_len) {
739 point_encode(G, &P, cc);
740 }
741 return r;
742 }
743
744 static size_t
745 api_mulgen(unsigned char *R,
746 const unsigned char *x, size_t xlen, int curve)
747 {
748 const unsigned char *G;
749 size_t Glen;
750
751 G = api_generator(curve, &Glen);
752 memcpy(R, G, Glen);
753 api_mul(R, Glen, x, xlen, curve);
754 return Glen;
755 }
756
757 static uint32_t
758 api_muladd(unsigned char *A, const unsigned char *B, size_t len,
759 const unsigned char *x, size_t xlen,
760 const unsigned char *y, size_t ylen, int curve)
761 {
762 uint32_t r, t, z;
763 const curve_params *cc;
764 jacobian P, Q;
765
766 /*
767 * TODO: see about merging the two ladders. Right now, we do
768 * two independent point multiplications, which is a bit
769 * wasteful of CPU resources (but yields short code).
770 */
771
772 cc = id_to_curve(curve);
773 r = point_decode(&P, A, len, cc);
774 if (B == NULL) {
775 size_t Glen;
776
777 B = api_generator(curve, &Glen);
778 }
779 r &= point_decode(&Q, B, len, cc);
780 point_mul(&P, x, xlen, cc);
781 point_mul(&Q, y, ylen, cc);
782
783 /*
784 * We want to compute P+Q. Since the base points A and B are distinct
785 * from infinity, and the multipliers are non-zero and lower than the
786 * curve order, then we know that P and Q are non-infinity. This
787 * leaves two special situations to test for:
788 * -- If P = Q then we must use point_double().
789 * -- If P+Q = 0 then we must report an error.
790 */
791 t = point_add(&P, &Q, cc);
792 point_double(&Q, cc);
793 z = br_i15_iszero(P.c[2]);
794
795 /*
796 * If z is 1 then either P+Q = 0 (t = 1) or P = Q (t = 0). So we
797 * have the following:
798 *
799 * z = 0, t = 0 return P (normal addition)
800 * z = 0, t = 1 return P (normal addition)
801 * z = 1, t = 0 return Q (a 'double' case)
802 * z = 1, t = 1 report an error (P+Q = 0)
803 */
804 CCOPY(z & ~t, &P, &Q, sizeof Q);
805 point_encode(A, &P, cc);
806 r &= ~(z & t);
807
808 return r;
809 }
810
811 /* see bearssl_ec.h */
812 const br_ec_impl br_ec_prime_i15 = {
813 (uint32_t)0x03800000,
814 &api_generator,
815 &api_order,
816 &api_xoff,
817 &api_mul,
818 &api_mulgen,
819 &api_muladd
820 };