ecc: Support an opaque MPI handling in mpi_from_keyparam.
[libgcrypt.git] / tests / t-mpi-point.c
1 /* t-mpi-point.c  - Tests for mpi point functions
2  * Copyright (C) 2013 g10 Code GmbH
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <assert.h>
27 #include <stdarg.h>
28
29 #define PGM "t-mpi-point"
30 #include "t-common.h"
31
32 static struct
33 {
34   const char *desc;           /* Description of the curve.  */
35   const char *p;              /* Order of the prime field.  */
36   const char *a, *b;          /* The coefficients. */
37   const char *n;              /* The order of the base point.  */
38   const char *g_x, *g_y;      /* Base point.  */
39   const char *h;              /* Cofactor.  */
40 } test_curve[] =
41   {
42     {
43       "NIST P-192",
44       "0xfffffffffffffffffffffffffffffffeffffffffffffffff",
45       "0xfffffffffffffffffffffffffffffffefffffffffffffffc",
46       "0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
47       "0xffffffffffffffffffffffff99def836146bc9b1b4d22831",
48
49       "0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
50       "0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811",
51       "0x01"
52     },
53     {
54       "NIST P-224",
55       "0xffffffffffffffffffffffffffffffff000000000000000000000001",
56       "0xfffffffffffffffffffffffffffffffefffffffffffffffffffffffe",
57       "0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4",
58       "0xffffffffffffffffffffffffffff16a2e0b8f03e13dd29455c5c2a3d" ,
59
60       "0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
61       "0xbd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34",
62       "0x01"
63     },
64     {
65       "NIST P-256",
66       "0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
67       "0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
68       "0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
69       "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
70
71       "0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
72       "0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5",
73       "0x01"
74     },
75     {
76       "NIST P-384",
77       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
78       "ffffffff0000000000000000ffffffff",
79       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
80       "ffffffff0000000000000000fffffffc",
81       "0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875a"
82       "c656398d8a2ed19d2a85c8edd3ec2aef",
83       "0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf"
84       "581a0db248b0a77aecec196accc52973",
85
86       "0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a38"
87       "5502f25dbf55296c3a545e3872760ab7",
88       "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c0"
89       "0a60b1ce1d7e819d7a431d7c90ea0e5f",
90       "0x01"
91     },
92     {
93       "NIST P-521",
94       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
95       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
96       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
97       "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc",
98       "0x051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef10"
99       "9e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00",
100       "0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
101       "ffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409",
102
103       "0xc6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3d"
104       "baa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66",
105       "0x11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e6"
106       "62c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650",
107       "0x01"
108     },
109     {
110       "Ed25519",
111       "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED",
112       "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC",
113       "0x52036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978A3",
114       "0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED",
115       "0x216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A",
116       "0x6666666666666666666666666666666666666666666666666666666666666658",
117       "0x08"
118     },
119     { NULL, NULL, NULL, NULL, NULL, NULL }
120   };
121
122 /* A sample public key for NIST P-256.  */
123 static const char sample_p256_q[] =
124   "04"
125   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E"
126   "E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
127 static const char sample_p256_q_x[] =
128   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E";
129 static const char sample_p256_q_y[] =
130   "00E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
131
132
133 /* A sample public key for Ed25519.  */
134 static const char sample_ed25519_q[] =
135   "04"
136   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce"
137   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
138 static const char sample_ed25519_q_x[] =
139   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce";
140 static const char sample_ed25519_q_y[] =
141   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
142 static const char sample_ed25519_q_eddsa[] =
143   "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a";
144 static const char sample_ed25519_d[] =
145   "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60";
146
147
148 static void
149 print_mpi_2 (const char *text, const char *text2, gcry_mpi_t a)
150 {
151   gcry_error_t err;
152   char *buf;
153   void *bufaddr = &buf;
154
155   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
156   if (err)
157     fprintf (stderr, "%s%s: [error printing number: %s]\n",
158              text, text2? text2:"", gpg_strerror (err));
159   else
160     {
161       fprintf (stderr, "%s%s: %s\n", text, text2? text2:"", buf);
162       gcry_free (buf);
163     }
164 }
165
166
167 static void
168 print_mpi (const char *text, gcry_mpi_t a)
169 {
170   print_mpi_2 (text, NULL, a);
171 }
172
173
174 static void
175 print_point (const char *text, gcry_mpi_point_t a)
176 {
177   gcry_mpi_t x, y, z;
178
179   x = gcry_mpi_new (0);
180   y = gcry_mpi_new (0);
181   z = gcry_mpi_new (0);
182   gcry_mpi_point_get (x, y, z, a);
183   print_mpi_2 (text, ".x", x);
184   print_mpi_2 (text, ".y", y);
185   print_mpi_2 (text, ".z", z);
186   gcry_mpi_release (x);
187   gcry_mpi_release (y);
188   gcry_mpi_release (z);
189 }
190
191
192 static void
193 print_sexp (const char *prefix, gcry_sexp_t a)
194 {
195   char *buf;
196   size_t size;
197
198   if (prefix)
199     fputs (prefix, stderr);
200   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
201   buf = gcry_xmalloc (size);
202
203   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
204   fprintf (stderr, "%.*s", (int)size, buf);
205   gcry_free (buf);
206 }
207
208
209 static gcry_mpi_t
210 hex2mpi (const char *string)
211 {
212   gpg_error_t err;
213   gcry_mpi_t val;
214
215   err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
216   if (err)
217     die ("hex2mpi '%s' failed: %s\n", string, gpg_strerror (err));
218   return val;
219 }
220
221
222 /* Convert STRING consisting of hex characters into its binary
223    representation and return it as an allocated buffer. The valid
224    length of the buffer is returned at R_LENGTH.  The string is
225    delimited by end of string.  The function returns NULL on
226    error.  */
227 static void *
228 hex2buffer (const char *string, size_t *r_length)
229 {
230   const char *s;
231   unsigned char *buffer;
232   size_t length;
233
234   buffer = xmalloc (strlen(string)/2+1);
235   length = 0;
236   for (s=string; *s; s +=2 )
237     {
238       if (!hexdigitp (s) || !hexdigitp (s+1))
239         return NULL;           /* Invalid hex digits. */
240       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
241     }
242   *r_length = length;
243   return buffer;
244 }
245
246
247 static gcry_mpi_t
248 hex2mpiopa (const char *string)
249 {
250   char *buffer;
251   size_t buflen;
252   gcry_mpi_t val;
253
254   buffer = hex2buffer (string, &buflen);
255   if (!buffer)
256     die ("hex2mpiopa '%s' failed: parser error\n", string);
257   val = gcry_mpi_set_opaque (NULL, buffer, buflen*8);
258   if (!buffer)
259     die ("hex2mpiopa '%s' failed: set_opaque error\n", string);
260   return val;
261 }
262
263
264 /* Compare A to B, where B is given as a hex string.  */
265 static int
266 cmp_mpihex (gcry_mpi_t a, const char *b)
267 {
268   gcry_mpi_t bval;
269   int res;
270
271   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
272     bval = hex2mpiopa (b);
273   else
274     bval = hex2mpi (b);
275   res = gcry_mpi_cmp (a, bval);
276   gcry_mpi_release (bval);
277   return res;
278 }
279
280
281 /* Wrapper to emulate the libgcrypt internal EC context allocation
282    function.  */
283 static gpg_error_t
284 ec_p_new (gcry_ctx_t *r_ctx, gcry_mpi_t p, gcry_mpi_t a)
285 {
286   gpg_error_t err;
287   gcry_sexp_t sexp;
288
289   if (p && a)
290     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m)(a %m))", p, a);
291   else if (p)
292     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m))", p);
293   else if (a)
294     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (a %m))", a);
295   else
296     err = gcry_sexp_build (&sexp, NULL, "(ecdsa)");
297   if (err)
298     return err;
299   err = gcry_mpi_ec_new (r_ctx, sexp, NULL);
300   gcry_sexp_release (sexp);
301   return err;
302 }
303
304
305 \f
306 static void
307 set_get_point (void)
308 {
309   gcry_mpi_point_t point, point2;
310   gcry_mpi_t x, y, z;
311
312   wherestr = "set_get_point";
313   info ("checking point setting functions\n");
314
315   point = gcry_mpi_point_new (0);
316   x = gcry_mpi_set_ui (NULL, 17);
317   y = gcry_mpi_set_ui (NULL, 42);
318   z = gcry_mpi_set_ui (NULL, 11371);
319   gcry_mpi_point_get (x, y, z, point);
320   if (gcry_mpi_cmp_ui (x, 0)
321       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
322     fail ("new point not initialized to (0,0,0)\n");
323   gcry_mpi_point_snatch_get (x, y, z, point);
324   point = NULL;
325   if (gcry_mpi_cmp_ui (x, 0)
326       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
327     fail ("snatch_get failed\n");
328   gcry_mpi_release (x);
329   gcry_mpi_release (y);
330   gcry_mpi_release (z);
331
332   point = gcry_mpi_point_new (0);
333   x = gcry_mpi_set_ui (NULL, 17);
334   y = gcry_mpi_set_ui (NULL, 42);
335   z = gcry_mpi_set_ui (NULL, 11371);
336   gcry_mpi_point_set (point, x, y, z);
337   gcry_mpi_set_ui (x, 23);
338   gcry_mpi_set_ui (y, 24);
339   gcry_mpi_set_ui (z, 25);
340   gcry_mpi_point_get (x, y, z, point);
341   if (gcry_mpi_cmp_ui (x, 17)
342       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
343     fail ("point_set/point_get failed\n");
344   gcry_mpi_point_snatch_set (point, x, y, z);
345   x = gcry_mpi_new (0);
346   y = gcry_mpi_new (0);
347   z = gcry_mpi_new (0);
348   gcry_mpi_point_get (x, y, z, point);
349   if (gcry_mpi_cmp_ui (x, 17)
350       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
351     fail ("point_snatch_set/point_get failed\n");
352
353   point2 = gcry_mpi_point_copy (point);
354
355   gcry_mpi_point_get (x, y, z, point2);
356   if (gcry_mpi_cmp_ui (x, 17)
357       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
358     fail ("point_copy failed (1)\n");
359
360   gcry_mpi_point_release (point);
361
362   gcry_mpi_point_get (x, y, z, point2);
363   if (gcry_mpi_cmp_ui (x, 17)
364       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
365     fail ("point_copy failed (2)\n");
366
367   gcry_mpi_point_release (point2);
368
369   gcry_mpi_release (x);
370   gcry_mpi_release (y);
371   gcry_mpi_release (z);
372 }
373
374
375 static void
376 context_alloc (void)
377 {
378   gpg_error_t err;
379   gcry_ctx_t ctx;
380   gcry_mpi_t p, a;
381
382   wherestr = "context_alloc";
383   info ("checking context functions\n");
384
385   p = gcry_mpi_set_ui (NULL, 1);
386   a = gcry_mpi_set_ui (NULL, 1);
387   err = ec_p_new (&ctx, p, a);
388   if (err)
389     die ("ec_p_new returned an error: %s\n", gpg_strerror (err));
390   gcry_mpi_release (p);
391   gcry_mpi_release (a);
392   gcry_ctx_release (ctx);
393
394   p = NULL;
395   a = gcry_mpi_set_ui (NULL, 0);
396
397   err = ec_p_new (&ctx, p, a);
398   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
399     fail ("ec_p_new: bad parameter detection failed (1)\n");
400
401   gcry_mpi_release (a);
402   a = NULL;
403   err = ec_p_new (&ctx, p, a);
404   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
405     fail ("ec_p_new: bad parameter detection failed (2)\n");
406
407 }
408
409
410 static int
411 get_and_cmp_mpi (const char *name, const char *mpistring, const char *desc,
412                  gcry_ctx_t ctx)
413 {
414   gcry_mpi_t mpi;
415
416   mpi = gcry_mpi_ec_get_mpi (name, ctx, 1);
417   if (!mpi)
418     {
419       fail ("error getting parameter '%s' of curve '%s'\n", name, desc);
420       return 1;
421     }
422   if (debug)
423     print_mpi (name, mpi);
424   if (cmp_mpihex (mpi, mpistring))
425     {
426       fail ("parameter '%s' of curve '%s' does not match\n", name, desc);
427       gcry_mpi_release (mpi);
428       return 1;
429     }
430   gcry_mpi_release (mpi);
431   return 0;
432 }
433
434
435 static int
436 get_and_cmp_point (const char *name,
437                    const char *mpi_x_string, const char *mpi_y_string,
438                    const char *desc, gcry_ctx_t ctx)
439 {
440   gcry_mpi_point_t point;
441   gcry_mpi_t x, y, z;
442   int result = 0;
443
444   point = gcry_mpi_ec_get_point (name, ctx, 1);
445   if (!point)
446     {
447       fail ("error getting point parameter '%s' of curve '%s'\n", name, desc);
448       return 1;
449     }
450   if (debug)
451     print_point (name, point);
452
453   x = gcry_mpi_new (0);
454   y = gcry_mpi_new (0);
455   z = gcry_mpi_new (0);
456   gcry_mpi_point_snatch_get (x, y, z, point);
457   if (cmp_mpihex (x, mpi_x_string))
458     {
459       fail ("x coordinate of '%s' of curve '%s' does not match\n", name, desc);
460       result = 1;
461     }
462   if (cmp_mpihex (y, mpi_y_string))
463     {
464       fail ("y coordinate of '%s' of curve '%s' does not match\n", name, desc);
465       result = 1;
466     }
467   if (cmp_mpihex (z, "01"))
468     {
469       fail ("z coordinate of '%s' of curve '%s' is not 1\n", name, desc);
470       result = 1;
471     }
472   gcry_mpi_release (x);
473   gcry_mpi_release (y);
474   gcry_mpi_release (z);
475   return result;
476 }
477
478
479 static void
480 context_param (void)
481 {
482   gpg_error_t err;
483   int idx;
484   gcry_ctx_t ctx = NULL;
485   gcry_mpi_t q, d;
486   gcry_sexp_t keyparam;
487
488   wherestr = "context_param";
489
490   info ("checking standard curves\n");
491   for (idx=0; test_curve[idx].desc; idx++)
492     {
493       /* P-192 and Ed25519 are not supported in fips mode */
494       if (gcry_fips_mode_active())
495         {
496           if (!strcmp(test_curve[idx].desc, "NIST P-192")
497               || !strcmp(test_curve[idx].desc, "Ed25519"))
498             {
499               info ("skipping %s in fips mode\n", test_curve[idx].desc );
500               continue;
501             }
502         }
503
504       gcry_ctx_release (ctx);
505       err = gcry_mpi_ec_new (&ctx, NULL, test_curve[idx].desc);
506       if (err)
507         {
508           fail ("can't create context for curve '%s': %s\n",
509                 test_curve[idx].desc, gpg_strerror (err));
510           continue;
511         }
512       if (get_and_cmp_mpi ("p", test_curve[idx].p, test_curve[idx].desc, ctx))
513         continue;
514       if (get_and_cmp_mpi ("a", test_curve[idx].a, test_curve[idx].desc, ctx))
515         continue;
516       if (get_and_cmp_mpi ("b", test_curve[idx].b, test_curve[idx].desc, ctx))
517         continue;
518       if (get_and_cmp_mpi ("g.x",test_curve[idx].g_x, test_curve[idx].desc,ctx))
519         continue;
520       if (get_and_cmp_mpi ("g.y",test_curve[idx].g_y, test_curve[idx].desc,ctx))
521         continue;
522       if (get_and_cmp_mpi ("n", test_curve[idx].n, test_curve[idx].desc, ctx))
523         continue;
524       if (get_and_cmp_point ("g", test_curve[idx].g_x, test_curve[idx].g_y,
525                              test_curve[idx].desc, ctx))
526         continue;
527       if (get_and_cmp_mpi ("h", test_curve[idx].h, test_curve[idx].desc, ctx))
528         continue;
529
530     }
531
532   info ("checking sample public key (nistp256)\n");
533   q = hex2mpi (sample_p256_q);
534   err = gcry_sexp_build (&keyparam, NULL,
535                         "(public-key(ecc(curve %s)(q %m)))",
536                         "NIST P-256", q);
537   if (err)
538     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
539   gcry_mpi_release (q);
540
541   /* We can't call gcry_pk_testkey because it is only implemented for
542      private keys.  */
543   /* err = gcry_pk_testkey (keyparam); */
544   /* if (err) */
545   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
546   /*         gpg_strerror (err)); */
547
548   gcry_ctx_release (ctx);
549   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
550   if (err)
551     fail ("gcry_mpi_ec_new failed for sample public key (nistp256): %s\n",
552           gpg_strerror (err));
553   else
554     {
555       gcry_sexp_t sexp;
556
557       get_and_cmp_mpi ("q", sample_p256_q, "nistp256", ctx);
558       get_and_cmp_point ("q", sample_p256_q_x, sample_p256_q_y, "nistp256",
559                          ctx);
560
561       /* Delete Q.  */
562       err = gcry_mpi_ec_set_mpi ("q", NULL, ctx);
563       if (err)
564         fail ("clearing Q for nistp256 failed: %s\n", gpg_strerror (err));
565       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
566         fail ("clearing Q for nistp256 did not work\n");
567
568       /* Set Q again.  */
569       q = hex2mpi (sample_p256_q);
570       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
571       if (err)
572         fail ("setting Q for nistp256 failed: %s\n", gpg_strerror (err));
573       get_and_cmp_mpi ("q", sample_p256_q, "nistp256(2)", ctx);
574       gcry_mpi_release (q);
575
576       /* Get as s-expression.  */
577       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
578       if (err)
579         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
580       else if (debug)
581         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
582       gcry_sexp_release (sexp);
583
584       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
585       if (err)
586         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
587               gpg_strerror (err));
588       else if (debug)
589         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
590       gcry_sexp_release (sexp);
591
592       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
593       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
594         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
595               gpg_strerror (err));
596       gcry_sexp_release (sexp);
597     }
598
599   /* Skipping Ed25519 if in FIPS mode (it isn't supported) */
600   if (gcry_fips_mode_active())
601     goto cleanup;
602
603   info ("checking sample public key (Ed25519)\n");
604   q = hex2mpi (sample_ed25519_q);
605   gcry_sexp_release (keyparam);
606   err = gcry_sexp_build (&keyparam, NULL,
607                         "(public-key(ecc(curve %s)(flags eddsa)(q %m)))",
608                         "Ed25519", q);
609   if (err)
610     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
611   gcry_mpi_release (q);
612
613   /* We can't call gcry_pk_testkey because it is only implemented for
614      private keys.  */
615   /* err = gcry_pk_testkey (keyparam); */
616   /* if (err) */
617   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
618   /*         gpg_strerror (err)); */
619
620   gcry_ctx_release (ctx);
621   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
622   if (err)
623     fail ("gcry_mpi_ec_new failed for sample public key: %s\n",
624           gpg_strerror (err));
625   else
626     {
627       gcry_sexp_t sexp;
628
629       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519", ctx);
630       get_and_cmp_point ("q", sample_ed25519_q_x, sample_ed25519_q_y,
631                          "Ed25519", ctx);
632       get_and_cmp_mpi ("q@eddsa", sample_ed25519_q_eddsa, "Ed25519", ctx);
633
634       /* Set d to see whether Q is correctly re-computed.  */
635       d = hex2mpi (sample_ed25519_d);
636       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
637       if (err)
638         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
639       gcry_mpi_release (d);
640       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(recompute Q)", ctx);
641
642       /* Delete Q by setting d and then clearing d.  The clearing is
643          required so that we can check whether Q has been cleared and
644          because further tests only expect a public key.  */
645       d = hex2mpi (sample_ed25519_d);
646       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
647       if (err)
648         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
649       gcry_mpi_release (d);
650       err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
651       if (err)
652         fail ("setting d for Ed25519 failed(2): %s\n", gpg_strerror (err));
653       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
654         fail ("setting d for Ed25519 did not reset Q\n");
655
656       /* Set Q again.  We need to use an opaque MPI here because
657          sample_ed25519_q is in uncompressed format which can only be
658          auto-detected if passed opaque.  */
659       q = hex2mpiopa (sample_ed25519_q);
660       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
661       if (err)
662         fail ("setting Q for Ed25519 failed: %s\n", gpg_strerror (err));
663       gcry_mpi_release (q);
664       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(2)", ctx);
665
666       /* Get as s-expression.  */
667       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
668       if (err)
669         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
670       else if (debug)
671         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
672       gcry_sexp_release (sexp);
673
674       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
675       if (err)
676         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
677               gpg_strerror (err));
678       else if (debug)
679         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
680       gcry_sexp_release (sexp);
681
682       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
683       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
684         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
685               gpg_strerror (err));
686       gcry_sexp_release (sexp);
687
688     }
689
690  cleanup:
691   gcry_ctx_release (ctx);
692   gcry_sexp_release (keyparam);
693 }
694
695
696
697
698 /* Create a new point from (X,Y,Z) given as hex strings.  */
699 gcry_mpi_point_t
700 make_point (const char *x, const char *y, const char *z)
701 {
702   gcry_mpi_point_t point;
703
704   point = gcry_mpi_point_new (0);
705   gcry_mpi_point_snatch_set (point, hex2mpi (x), hex2mpi (y), hex2mpi (z));
706
707   return point;
708 }
709
710
711 /* This tests checks that the low-level EC API yields the same result
712    as using the high level API.  The values have been taken from a
713    test run using the high level API.  */
714 static void
715 basic_ec_math (void)
716 {
717   gpg_error_t err;
718   gcry_ctx_t ctx;
719   gcry_mpi_t P, A;
720   gcry_mpi_point_t G, Q;
721   gcry_mpi_t d;
722   gcry_mpi_t x, y, z;
723
724   wherestr = "basic_ec_math";
725   info ("checking basic math functions for EC\n");
726
727   P = hex2mpi ("0xfffffffffffffffffffffffffffffffeffffffffffffffff");
728   A = hex2mpi ("0xfffffffffffffffffffffffffffffffefffffffffffffffc");
729   G = make_point ("188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012",
730                   "7192B95FFC8DA78631011ED6B24CDD573F977A11E794811",
731                   "1");
732   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
733   Q = gcry_mpi_point_new (0);
734
735   err = ec_p_new (&ctx, P, A);
736   if (err)
737     die ("ec_p_new failed: %s\n", gpg_strerror (err));
738
739   x = gcry_mpi_new (0);
740   y = gcry_mpi_new (0);
741   z = gcry_mpi_new (0);
742
743   {
744     /* A quick check that multiply by zero works.  */
745     gcry_mpi_t tmp;
746
747     tmp = gcry_mpi_new (0);
748     gcry_mpi_ec_mul (Q, tmp, G, ctx);
749     gcry_mpi_release (tmp);
750     gcry_mpi_point_get (x, y, z, Q);
751     if (gcry_mpi_cmp_ui (z, 0))
752       fail ("multiply a point by zero failed\n");
753   }
754
755   gcry_mpi_ec_mul (Q, d, G, ctx);
756
757   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
758     fail ("failed to get affine coordinates\n");
759   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
760       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
761     fail ("computed affine coordinates of public key do not match\n");
762   if (debug)
763     {
764       print_mpi ("q.x", x);
765       print_mpi ("q.y", y);
766     }
767
768   gcry_mpi_release (z);
769   gcry_mpi_release (y);
770   gcry_mpi_release (x);
771   gcry_mpi_point_release (Q);
772   gcry_mpi_release (d);
773   gcry_mpi_point_release (G);
774   gcry_mpi_release (A);
775   gcry_mpi_release (P);
776   gcry_ctx_release (ctx);
777 }
778
779
780 /* This is the same as basic_ec_math but uses more advanced
781    features.  */
782 static void
783 basic_ec_math_simplified (void)
784 {
785   gpg_error_t err;
786   gcry_ctx_t ctx;
787   gcry_mpi_point_t G, Q;
788   gcry_mpi_t d;
789   gcry_mpi_t x, y, z;
790   gcry_sexp_t sexp;
791
792   wherestr = "basic_ec_math_simplified";
793   info ("checking basic math functions for EC (variant)\n");
794
795   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
796   Q = gcry_mpi_point_new (0);
797
798   err = gcry_mpi_ec_new (&ctx, NULL, "NIST P-192");
799   if (err)
800     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
801   G = gcry_mpi_ec_get_point ("g", ctx, 1);
802   if (!G)
803     die ("gcry_mpi_ec_get_point(G) failed\n");
804   gcry_mpi_ec_mul (Q, d, G, ctx);
805
806   x = gcry_mpi_new (0);
807   y = gcry_mpi_new (0);
808   z = gcry_mpi_new (0);
809
810   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
811     fail ("failed to get affine coordinates\n");
812   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
813       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
814     fail ("computed affine coordinates of public key do not match\n");
815   if (debug)
816     {
817       print_mpi ("q.x", x);
818       print_mpi ("q.y", y);
819     }
820
821   gcry_mpi_release (z);
822   gcry_mpi_release (y);
823   gcry_mpi_release (x);
824
825   /* Let us also check whether we can update the context.  */
826   err = gcry_mpi_ec_set_point ("g", G, ctx);
827   if (err)
828     die ("gcry_mpi_ec_set_point(G) failed\n");
829   err = gcry_mpi_ec_set_mpi ("d", d, ctx);
830   if (err)
831     die ("gcry_mpi_ec_set_mpi(d) failed\n");
832
833   /* FIXME: Below we need to check that the returned S-expression is
834      as requested.  For now we use manual inspection using --debug.  */
835
836   /* Does get_sexp return the private key?  */
837   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
838   if (err)
839     fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
840   else if (debug)
841     print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
842   gcry_sexp_release (sexp);
843
844   /* Does get_sexp return the public key if requested?  */
845   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
846   if (err)
847     fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n", gpg_strerror (err));
848   else if (debug)
849     print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
850   gcry_sexp_release (sexp);
851
852   /* Does get_sexp return the public key after d has been deleted?  */
853   err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
854   if (err)
855     die ("gcry_mpi_ec_set_mpi(d=NULL) failed\n");
856   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
857   if (err)
858     fail ("gcry_pubkey_get_sexp(0 w/o d) failed: %s\n", gpg_strerror (err));
859   else if (debug)
860     print_sexp ("Result of gcry_pubkey_get_sexp (0 w/o d):\n", sexp);
861   gcry_sexp_release (sexp);
862
863   /* Does get_sexp return an error after d has been deleted?  */
864   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
865   if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
866     fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
867           gpg_strerror (err));
868   gcry_sexp_release (sexp);
869
870   /* Does get_sexp return an error after d and Q have been deleted?  */
871   err = gcry_mpi_ec_set_point ("q", NULL, ctx);
872   if (err)
873     die ("gcry_mpi_ec_set_point(q=NULL) failed\n");
874   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
875   if (gpg_err_code (err) != GPG_ERR_BAD_CRYPT_CTX)
876     fail ("gcry_pubkey_get_sexp(0 w/o Q,d) returned wrong error: %s\n",
877           gpg_strerror (err));
878   gcry_sexp_release (sexp);
879
880
881   gcry_mpi_point_release (Q);
882   gcry_mpi_release (d);
883   gcry_mpi_point_release (G);
884   gcry_ctx_release (ctx);
885 }
886
887
888 /* Check the math used with Twisted Edwards curves.  */
889 static void
890 twistededwards_math (void)
891 {
892   gpg_error_t err;
893   gcry_ctx_t ctx;
894   gcry_mpi_point_t G, Q;
895   gcry_mpi_t k;
896   gcry_mpi_t w, a, x, y, z, p, n, b, I;
897
898   wherestr = "twistededwards_math";
899   info ("checking basic Twisted Edwards math\n");
900
901   err = gcry_mpi_ec_new (&ctx, NULL, "Ed25519");
902   if (err)
903     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
904
905   k = hex2mpi
906     ("2D3501E723239632802454EE5DDC406EFB0BDF18486A5BDE9C0390A9C2984004"
907      "F47252B628C953625B8DEB5DBCB8DA97AA43A1892D11FA83596F42E0D89CB1B6");
908   G = gcry_mpi_ec_get_point ("g", ctx, 1);
909   if (!G)
910     die ("gcry_mpi_ec_get_point(G) failed\n");
911   Q = gcry_mpi_point_new (0);
912
913
914   w = gcry_mpi_new (0);
915   a = gcry_mpi_new (0);
916   x = gcry_mpi_new (0);
917   y = gcry_mpi_new (0);
918   z = gcry_mpi_new (0);
919   I = gcry_mpi_new (0);
920   p = gcry_mpi_ec_get_mpi ("p", ctx, 1);
921   n = gcry_mpi_ec_get_mpi ("n", ctx, 1);
922   b = gcry_mpi_ec_get_mpi ("b", ctx, 1);
923
924   /* Check: 2^{p-1} mod p == 1 */
925   gcry_mpi_sub_ui (a, p, 1);
926   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, p);
927   if (gcry_mpi_cmp_ui (w, 1))
928     fail ("failed assertion: 2^{p-1} mod p == 1\n");
929
930   /* Check: p % 4 == 1 */
931   gcry_mpi_mod (w, p, GCRYMPI_CONST_FOUR);
932   if (gcry_mpi_cmp_ui (w, 1))
933     fail ("failed assertion: p %% 4 == 1\n");
934
935   /* Check: 2^{n-1} mod n == 1 */
936   gcry_mpi_sub_ui (a, n, 1);
937   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, n);
938   if (gcry_mpi_cmp_ui (w, 1))
939     fail ("failed assertion: 2^{n-1} mod n == 1\n");
940
941   /* Check: b^{(p-1)/2} mod p == p-1 */
942   gcry_mpi_sub_ui (a, p, 1);
943   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_TWO, -1);
944   gcry_mpi_powm (w, b, x, p);
945   gcry_mpi_abs (w);
946   if (gcry_mpi_cmp (w, a))
947     fail ("failed assertion: b^{(p-1)/2} mod p == p-1\n");
948
949   /* I := 2^{(p-1)/4} mod p */
950   gcry_mpi_sub_ui (a, p, 1);
951   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_FOUR, -1);
952   gcry_mpi_powm (I, GCRYMPI_CONST_TWO, x, p);
953
954   /* Check: I^2 mod p == p-1 */
955   gcry_mpi_powm (w, I, GCRYMPI_CONST_TWO, p);
956   if (gcry_mpi_cmp (w, a))
957     fail ("failed assertion: I^2 mod p == p-1\n");
958
959   /* Check: G is on the curve */
960   if (!gcry_mpi_ec_curve_point (G, ctx))
961     fail ("failed assertion: G is on the curve\n");
962
963   /* Check: nG == (0,1) */
964   gcry_mpi_ec_mul (Q, n, G, ctx);
965   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
966     fail ("failed to get affine coordinates\n");
967   if (gcry_mpi_cmp_ui (x, 0) || gcry_mpi_cmp_ui (y, 1))
968     fail ("failed assertion: nG == (0,1)\n");
969
970   /* Now two arbitrary point operations taken from the ed25519.py
971      sample data.  */
972   gcry_mpi_release (a);
973   a = hex2mpi
974     ("4f71d012df3c371af3ea4dc38385ca5bb7272f90cb1b008b3ed601c76de1d496"
975      "e30cbf625f0a756a678d8f256d5325595cccc83466f36db18f0178eb9925edd3");
976   gcry_mpi_ec_mul (Q, a, G, ctx);
977   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
978     fail ("failed to get affine coordinates\n");
979   if (cmp_mpihex (x, ("157f7361c577aad36f67ed33e38dc7be"
980                       "00014fecc2165ca5cee9eee19fe4d2c1"))
981       || cmp_mpihex (y, ("5a69dbeb232276b38f3f5016547bb2a2"
982                          "4025645f0b820e72b8cad4f0a909a092")))
983     {
984       fail ("sample point multiply failed:\n");
985       print_mpi ("r", a);
986       print_mpi ("Rx", x);
987       print_mpi ("Ry", y);
988     }
989
990   gcry_mpi_release (a);
991   a = hex2mpi
992     ("2d3501e723239632802454ee5ddc406efb0bdf18486a5bde9c0390a9c2984004"
993      "f47252b628c953625b8deb5dbcb8da97aa43a1892d11fa83596f42e0d89cb1b6");
994   gcry_mpi_ec_mul (Q, a, G, ctx);
995   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
996     fail ("failed to get affine coordinates\n");
997   if (cmp_mpihex (x, ("6218e309d40065fcc338b3127f468371"
998                       "82324bd01ce6f3cf81ab44e62959c82a"))
999       || cmp_mpihex (y, ("5501492265e073d874d9e5b81e7f8784"
1000                          "8a826e80cce2869072ac60c3004356e5")))
1001     {
1002       fail ("sample point multiply failed:\n");
1003       print_mpi ("r", a);
1004       print_mpi ("Rx", x);
1005       print_mpi ("Ry", y);
1006     }
1007
1008
1009   gcry_mpi_release (I);
1010   gcry_mpi_release (b);
1011   gcry_mpi_release (n);
1012   gcry_mpi_release (p);
1013   gcry_mpi_release (w);
1014   gcry_mpi_release (a);
1015   gcry_mpi_release (x);
1016   gcry_mpi_release (y);
1017   gcry_mpi_release (z);
1018   gcry_mpi_point_release (Q);
1019   gcry_mpi_point_release (G);
1020   gcry_mpi_release (k);
1021   gcry_ctx_release (ctx);
1022 }
1023
1024
1025 /* Check the point on curve function.  */
1026 static void
1027 point_on_curve (void)
1028 {
1029   static struct {
1030     const char *curve;
1031     int oncurve;      /* Point below is on the curve.  */
1032     const char *qx;
1033     const char *qy;
1034   } t[] = {
1035     {
1036       "NIST P-256", 0,
1037       "015B4F6775D68D4D2E2192C6B8027FC5A3D49957E453CB251155AA3FF5D3EC9974",
1038       "4BC4C87B57A25E1056831208AB5B8F091142F891E9FF19F1E090B030DF1087B3"
1039     }, {
1040       "NIST P-256", 0,
1041       "D22C316E7EBE7B293BD66808E000806F0754398A5D72A4F9BBC21C26EAC0A651",
1042       "3C8DB80CC3CDE5E530D040536E6A58AAB41C33FA70B30896943513FF3690132D"
1043     }, {
1044       "NIST P-256", 0,
1045       "0130F7E7BC52854CA493A0DE87DC4AB3B4343758F2B634F15B10D70DBC0A5A5291",
1046       "86F9CA73C25CE86D54CB21C181AECBB52A5971334FF5040F76CAE9845ED46023"
1047     }, {
1048       "NIST P-256", 1,
1049       "14957B602C7849F28858C7407696F014BC091D6D68C449560B7A38147D6E6A9B",
1050       "A8E09EFEECFE00C797A0848F38B61992D30C61FAB13021E88C8BD3545B3A6C63"
1051     }, {
1052       "NIST P-256", 0,
1053       "923DE4957241DD97780841C76294DB0D4F5DC04C3045081174764D2D32AD2D53",
1054       "01B4B1A2027C02F0F520A3B01E4CE3C668BF481346A74499C5D1044A53E210B600"
1055     }, {
1056       "NIST P-256", 1,
1057       "9021DFAB8B4DAEAADA634AAA26D6E5FFDF8C0476FF5CA31606C870A1B933FB36",
1058       "9AFC65EEB24E46C7B75712EF29A981CB09FAC56E2B81D3ED024748CCAB1CB77E"
1059     }, {
1060       "NIST P-256", 0,
1061       "011529F0B26DE5E0EB2DA4BFB6C149C802CB52EE479DD666553286928A4005E990",
1062       "0EBC63DB2104884456DC0AA81A3F4E99D93B7AE2CD4B1489655EA9BE6289CF9E"
1063     }, {
1064       "NIST P-256", 1,
1065       "216EC5DE8CA989199D31F0DFCD381DCC9270A0785365EC3E34CA347C070A87BE",
1066       "87A88897BA763509ECC1DBE28D9D37F6F4E70E3B99B1CD3C0B934D4190968A6D"
1067     }, {
1068       "NIST P-256", 1,
1069       "7ABAA44ACBC6016FDB52A6F45F6178E65CBFC35F9920D99149CA9999612CE945",
1070       "88F7684BDCDA31EAFB6CAD859F8AB29B5D921D7DB2B34DF7E40CE36235F45B63"
1071     }, {
1072       "NIST P-256", 0,
1073       "E765B4272D211DD0064189B55421FB76BB3A7756364A6CB1627FAED848157A84",
1074       "C13171CFFB243E06B203F0996BBDD16F52292AD11F2DA81106E9C2FD87F4FA0F"
1075     }, {
1076       "NIST P-256", 0,
1077       "EE4999DFC3A1871EE7A592BE26A09BEC9D9B561613EE9EFB6ED42F17985C9CDC",
1078       "8399E967338A7A618336AF70DA67D9CAC1C19267809652F5C5183C8B129E0902"
1079     }, {
1080       "NIST P-256", 0,
1081       "F755D0CF2642A2C7FBACCC8E9E442B8B047A99C6E052B2FA5AB0544B36B4D51C",
1082       "AA080F17657B6565D9A4D94BD260B54D92FEE8DC4A78C4FC9C19209933AF39B0"
1083     } , {
1084       "NIST P-384", 0,
1085       "CBFC7DBEBF15BEAD682549757F9BBA0E3F67669DF13FCE0EBE8024B725B38B00"
1086       "83EC46A8F2FF3203C5C7F8C7E722A5EF",
1087       "0548FE281BEAB18FD1AB86F59B0CA524479A4A81373C83B78AFFD801FAC75922"
1088       "96470753DCF46173C9AA4A8A4C2FBE51"
1089     }, {
1090       "NIST P-384", 0,
1091       "1DC8E054A883DB81EAEDE6C487B26816C927B8196780525A6CA8F675D2557752"
1092       "02CE06CCBE705EA8A38AA2894D4BEEE6",
1093       "010191050E867AFAA96A199FE9C591CF8B853D81486786DA889124881FB39D2F"
1094       "8E0875F4C4BB1E3D0F8535C7A52306FB82"
1095     }, {
1096       "NIST P-384", 1,
1097       "2539FC368CE1D5E464B6C0FBB12D557B712327DB086975255AD7D17F7E7E4F23"
1098       "D719ED4116E2CC907AEB92CF22331A60",
1099       "8843FDBA742CB64323E49CEBE8DD74908CFC9C3AA0015662DFBB7219E92CF32E"
1100       "9FC63F61EF19DE9B3CEA98D163ABF254"
1101     }, {
1102       "NIST P-384", 0,
1103       "0B786DACF400D43575394349EDD9F9CD145FC7EF737A3C5F69B253BE7639DB24"
1104       "EC2F0CA62FF1F90B6515DE356EC2A404",
1105       "225D6B2939CC7F7133F43353946A682C68DAC6BB75EE9CF6BD9A1609FA915692"
1106       "72F4D3A87E88529754E109BB9B61B03B"
1107     }, {
1108       "NIST P-384", 0,
1109       "76C660C9F58CF2051F9F8B06049694AB6FE418009DE6F0A0833BC690CEC06CC2"
1110       "9A440AD51C94CF5BC28817C8C6E2D302",
1111       "012974E5D9E55304ED294AB6C7A3C65B663E67ABC5E6F6C0F6498B519F2F6CA1"
1112       "8306976291F3ADC0B5ABA42DED376EA9A5"
1113     }, {
1114       "NIST P-384", 0,
1115       "23D758B1EDB8E12E9E707C53C131A19D9464B20EE05C99766F5ABDF9F906AD03"
1116       "B958BF28B022E54E320672C4BAD4EEC0",
1117       "01E9E72870C88F4C82A5AB3CC8A3398E8F006BF3EC05FFBB1EFF8AEE88020FEA"
1118       "9E558E9F58ED1D324C9DCBCB4E8F2A5970"
1119     }, {
1120       "NIST P-384", 0,
1121       "D062B96D5A10F715ACF361F99262ABF0F7693A8BB60ECB1DF459CF95750E4293"
1122       "18BCB9FC60499D009F949298F3F9F47B",
1123       "9089C6328E4B39A73D7EE6FAE1A77E48CE354B83BBCE432082C32C8FD6784B86"
1124       "CFE9C552E2E720F5DA5806503D3784CD"
1125     }, {
1126       "NIST P-384", 0,
1127       "2A951D4D6EB35C43D94866280D37365B82441BC84D62CBFF3365CAB1FD0A3E20"
1128       "823CA8F84D2BBF4EA687885437DE7839",
1129       "01CC7D762AFE613F7B5568BC516568A421159C40599E8D52DE10E8F9488931E1"
1130       "69F3656C322DE45C4A70DC6DB9A661E599"
1131     }, {
1132       "NIST P-384", 1,
1133       "A4BAEE6CDAF3AEB69032B3FBA811707C54F5753670DA5173D891547E8CBAEEF3"
1134       "89B92C9A55573A596123415FBFA26991",
1135       "3241EA716583C11C71BB30AF6C5E3A6637956F17ADBBE641BAB52E8539F9FC7B"
1136       "F3B04F46DBFFE08151E0F0950CC70081"
1137     }, {
1138       "NIST P-384", 0,
1139       "5C0E18B0DE3261BCBCFC7B702C2D75CF481336BFBADF420BADC616235C1966AB"
1140       "4C0F876575DDEC1BDB3F3F04061C9AE4",
1141       "E90C78550D1C922F1D8161D8C9C0576E29BD09CA665376FA887D13FA8DF48352"
1142       "D7BBEEFB803F6CC8FC7895E47F348D33"
1143     }, {
1144       "NIST P-384", 1,
1145       "2015864CD50F0A1A50E6401F44191665C19E4AD4B4903EA9EB464E95D1070E36"
1146       "F1D8325E45734D5A0FDD103F4DF6F83E",
1147       "5FB3E9A5C59DD5C5262A8176CB7032A00AE33AED08485884A3E5D68D9EEB990B"
1148       "F26E8D87EC175577E782AD51A6A12C02"
1149     }, {
1150       "NIST P-384", 1,
1151       "56EBF5310EEF5A5D8D001F570A18625383ECD4882B3FC738A69874E7C9D8F89C"
1152       "187BECA23369DFD6C15CC0DA0629958F",
1153       "C1230B349FB662CB762563DB8F9FCB32D5CCA16120681C474D67D279CCA6F6DB"
1154       "73DE6AA96140B5C457B7486E06D318CE"
1155     }, {
1156       "NIST P-521", 0,
1157       "01E4D82EE5CD6DA37080252295EFA273BBBA6952012D0120EAF131E73F1E5024"
1158       "36E3324624471040030E1C345D65490ECEE9B64E03B15B6C7EB69A39C618BAFEED70",
1159       "03EE3A3C88A6933B7B16016BE4CC4E3BF5EA0625CB3DB2604CDCBBD02CABBC90"
1160       "8904D9DB42998F6C5101D4D4318ACFC9643C9CD641F636D1810ED86F1840EA74F3C0"
1161     }, {
1162       "NIST P-521", 0,
1163       "01F3DFCB5433387B6B2E3F74177F4F3D7300F05E1AD49DE112630E27B1C8A437"
1164       "1E742CB020E0039B5477FC897D17332034F9660B3066764EFF5FB440EB8856E782E3",
1165       "02D337616C9D202DC5E290C486F5855CBD6A8470AE62CA96245834CF49257D8D"
1166       "96D4041B15007650DEE668C00DDBF749054256C571F60980AC74D0DBCA7FB96C2F48"
1167     }, {
1168       "NIST P-521", 1,
1169       "822A846606DC9E96452CAC373567A8B57D9ACA15B177F75DD7EF10C635F52CE4"
1170       "EF6ABEEDB90D3F48F50A0C9015A95C955A25C45DE8413DE3BF899B6B1E62CF7CB8",
1171       "0102771B5F3EC8C36838CEC04DCBC28AD1E38C37DAB0EA89B5EE92D21F7A35CE"
1172       "ABC8B155EDC70154D6DFA2E77EC1D8C4A3406A6BD0ECF8F1EE2AC33A02464CB70C97"
1173     }, {
1174       "NIST P-521", 0,
1175       "F733D48467912D1FFE46CF442F27FDD218D190E7B8A829D822DA3B6BAF9B987E"
1176       "5B4BCCE34499248F59EEAF74F63ED15FF73F243C6FC3FD5E5842F6A3BA34C2022D",
1177       "0281AAAD1B7EEBABEB6EC67932CB7E95717AFA3B4CF7A2DB151CD537C419C3A5"
1178       "156ED9160758190B47696CDC15E81BBAD12975283907A571604DB23F702AEA4B38FF"
1179     }, {
1180       "NIST P-521", 0,
1181       "03B1B274175AAEB5907152E5114CCAEADA28A7ADD4A2B1831C3D8302E8596489"
1182       "E2C98B9B8D0CAE98C03BB11E28CE66D4736449758AF58BAFE40EF5A5FA22C9A43117",
1183       "94C5951F81D544E959EDFC5DC1D5F42FE427871D4FB91A43A0B4A6BEA6B35B9E"
1184       "BC5FB444C70BE4FD47B4ED16704F8C86EF019FC47C7FF2271F8B0DDEA9E2D3BCDD"
1185     }, {
1186       "NIST P-521", 1,
1187       "F2248C318055DE37CD706D4FCAF7E7D96737A4A7B6B8067A66DCD58B6B8DFC55"
1188       "90ECE67F6AA67F9C51B57E7B023075F2F42909BF47361CB6881C10F55FB7215B56",
1189       "0162F735CE6A2ADA54CAF96A12D6888C02DE0A74638CF34CE39DABBACA4D651B"
1190       "7E6ED1A65B551B36BAE7BE474BB6E6905ED0E33C7BA2021885027C7C6E40C5613004"
1191     }, {
1192       "NIST P-521", 0,
1193       "9F08E97FEADCF0A391CA1EA4D97B5FE62D3B164593E12027EB967BD6E1FA841A"
1194       "9831158DF164BCAD0BF3ADA96127745E25F349BDDD52EEA1654892B35960C9C023",
1195       "AE2A25F5440F258AFACA6925C4C9F7AEAD3CB67153C4FACB31AC33F58B43A78C"
1196       "B14F682FF726CEE2A6B6F6B481AEEB29A9B3150F02D1CFB764672BA8294C477291"
1197     }, {
1198       "NIST P-521", 0,
1199       "01047B52014748C904980716953206A93F0D01B34CA94A997407FA93FE304F86"
1200       "17BB6E402B2BB8B434C2671ECE953ABE7BADB75713CD9DF950943A33A9A19ACCDABE",
1201       "7433533F098037DEA616337986887D01C5CC8DEC3DC1FDB9CDF7287EF27CC125"
1202       "54FCF3A5E212DF9DAD9F8A3A7173B23FC6E15930704F3AEE1B074BDDB0ED6823E4"
1203     }, {
1204       "NIST P-521", 0,
1205       "01C2A9EBF51592FE6589F618EAADA1697D9B2EC7CE5D48C9E80FC597642B23F1"
1206       "F0EBE953449762BD3F094F57791D9850AFE98BBDA9872BE399B7BDD617860076BB03",
1207       "0B822E27692F63DB8E12C59BB3CCA172B9BBF613CAE5F9D1474186E45E8B26FF"
1208       "962084E1C6BE74821EDBB60941A3B75516F603719563433383812BFEA89EC14B89"
1209     }, {
1210       "NIST P-521", 0,
1211       "99390F342C3F0D46E80C5B65C61E8AA8ACA0B6D4E1352404586364A05D8398E9"
1212       "2BC71A644E8663F0A9B87D0B3ACAEE32F2AB9B321317AD23059D045EBAB91C5D93",
1213       "82FCF93AE4467EB57766F2B150E736636727E7282500CD482DA70D153D195F2B"
1214       "DF9B96D689A0DC1BB9137B41557A33F202F1B71840544CBEFF03072E77E4BB6F0B"
1215     }, {
1216       "NIST P-521", 1,
1217       "018E48E80594FF5496D8CC7DF8A19D6AA18805A4EF4490038AED6A1E9AA18056"
1218       "D0244A97DCF6D132C6804E3F4F369922119544B4C057D783C848FB798B48730A382C",
1219       "01AF510B4F5E1C40BC9C110216D35E7C6D7A2BEE52914FC98258676288449901"
1220       "F27A07EE91DF2D5D79259712906C3E18A990CBF35BCAC41A952820CE2BA8D0220080"
1221     }, {
1222       "NIST P-521", 1,
1223       "ADCEF3539B4BC831DC0AFD173137A4426152058AFBAE06A17FCB89F4DB6E48B5"
1224       "335CB88F8E4DB475A1E390E5656072F06605BFB84CBF9795B7992ECA04A8E10CA1",
1225       "01BCB985AFD6404B9EDA49B6190AAA346BF7D5909CA440C0F7E505C62FAC8635"
1226       "31D3EB7B2AC4DD4F4404E4B12E9D6D3C596179587F3724B1EFFF684CFDB4B21826B9"
1227     }
1228   };
1229   gpg_error_t err;
1230   int tidx;
1231   const char *lastcurve = NULL;
1232   gcry_ctx_t ctx = NULL;
1233   gcry_mpi_t qx = NULL;
1234   gcry_mpi_t qy = NULL;
1235   gcry_mpi_point_t Q;
1236   int oncurve;
1237
1238   wherestr = "point_on_curve";
1239   for (tidx=0; tidx < DIM (t); tidx++)
1240     {
1241       if (!t[tidx].curve)
1242         {
1243           if (!lastcurve || !ctx)
1244             die ("invalid test vectors at idx %d\n", tidx);
1245         }
1246       else if (!ctx || !lastcurve || strcmp (t[tidx].curve, lastcurve))
1247         {
1248           lastcurve = t[tidx].curve;
1249           gcry_ctx_release (ctx);
1250           err = gcry_mpi_ec_new (&ctx, NULL, lastcurve);
1251           if (err)
1252             die ("error creating context for curve %s at idx %d: %s\n",
1253                  lastcurve, tidx, gpg_strerror (err));
1254
1255           info ("checking points on curve %s\n", lastcurve);
1256         }
1257
1258       gcry_mpi_release (qx);
1259       gcry_mpi_release (qy);
1260       qx = hex2mpi (t[tidx].qx);
1261       qy = hex2mpi (t[tidx].qy);
1262
1263       Q = gcry_mpi_point_set (NULL, qx, qy, GCRYMPI_CONST_ONE);
1264       if (!Q)
1265         die ("gcry_mpi_point_set(Q) failed at idx %d\n", tidx);
1266
1267       oncurve = gcry_mpi_ec_curve_point (Q, ctx);
1268
1269       if (t[tidx].oncurve && !oncurve)
1270         {
1271           fail ("point expected on curve but not identified as such (i=%d):\n",
1272                 tidx);
1273           print_point ("  Q", Q);
1274         }
1275       else if (!t[tidx].oncurve && oncurve)
1276         {
1277           fail ("point not expected on curve but identified as such (i=%d):\n",
1278                 tidx);
1279           print_point ("  Q", Q);
1280         }
1281       gcry_mpi_point_release (Q);
1282     }
1283
1284   gcry_mpi_release (qx);
1285   gcry_mpi_release (qy);
1286   gcry_ctx_release (ctx);
1287 }
1288
1289
1290 int
1291 main (int argc, char **argv)
1292 {
1293
1294   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1295     verbose = 1;
1296   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1297     verbose = debug = 1;
1298
1299   if (!gcry_check_version (GCRYPT_VERSION))
1300     die ("version mismatch\n");
1301
1302   xgcry_control ((GCRYCTL_DISABLE_SECMEM, 0));
1303   xgcry_control ((GCRYCTL_ENABLE_QUICK_RANDOM, 0));
1304   if (debug)
1305     xgcry_control ((GCRYCTL_SET_DEBUG_FLAGS, 1u, 0));
1306   xgcry_control ((GCRYCTL_INITIALIZATION_FINISHED, 0));
1307
1308   set_get_point ();
1309   context_alloc ();
1310   context_param ();
1311   basic_ec_math ();
1312   point_on_curve ();
1313
1314   /* The tests are for P-192 and ed25519 which are not supported in
1315      FIPS mode.  */
1316   if (!gcry_fips_mode_active())
1317     {
1318       basic_ec_math_simplified ();
1319       twistededwards_math ();
1320     }
1321
1322   info ("All tests completed. Errors: %d\n", error_count);
1323   return error_count ? 1 : 0;
1324 }