88bb5bdfb6727d22763064431b37de5c80a3498f
[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 #include "../src/gcrypt-int.h"
30
31 #define PGM "t-mpi-point"
32
33 static const char *wherestr;
34 static int verbose;
35 static int debug;
36 static int error_count;
37
38
39 #define my_isascii(c) (!((c) & 0x80))
40 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
41 #define hexdigitp(a) (digitp (a)                     \
42                       || (*(a) >= 'A' && *(a) <= 'F')  \
43                       || (*(a) >= 'a' && *(a) <= 'f'))
44 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
45                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
46 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
47 #define xmalloc(a)    gcry_xmalloc ((a))
48 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
49 #define xfree(a)      gcry_free ((a))
50 #define pass() do { ; } while (0)
51
52
53 static struct
54 {
55   const char *desc;           /* Description of the curve.  */
56   const char *p;              /* Order of the prime field.  */
57   const char *a, *b;          /* The coefficients. */
58   const char *n;              /* The order of the base point.  */
59   const char *g_x, *g_y;      /* Base point.  */
60 } test_curve[] =
61   {
62     {
63       "NIST P-192",
64       "0xfffffffffffffffffffffffffffffffeffffffffffffffff",
65       "0xfffffffffffffffffffffffffffffffefffffffffffffffc",
66       "0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
67       "0xffffffffffffffffffffffff99def836146bc9b1b4d22831",
68
69       "0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
70       "0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
71     },
72     {
73       "NIST P-224",
74       "0xffffffffffffffffffffffffffffffff000000000000000000000001",
75       "0xfffffffffffffffffffffffffffffffefffffffffffffffffffffffe",
76       "0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4",
77       "0xffffffffffffffffffffffffffff16a2e0b8f03e13dd29455c5c2a3d" ,
78
79       "0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
80       "0xbd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34"
81     },
82     {
83       "NIST P-256",
84       "0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
85       "0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
86       "0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
87       "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
88
89       "0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
90       "0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
91     },
92     {
93       "NIST P-384",
94       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
95       "ffffffff0000000000000000ffffffff",
96       "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
97       "ffffffff0000000000000000fffffffc",
98       "0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875a"
99       "c656398d8a2ed19d2a85c8edd3ec2aef",
100       "0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf"
101       "581a0db248b0a77aecec196accc52973",
102
103       "0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a38"
104       "5502f25dbf55296c3a545e3872760ab7",
105       "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c0"
106       "0a60b1ce1d7e819d7a431d7c90ea0e5f"
107     },
108     {
109       "NIST P-521",
110       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
111       "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
112       "0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
113       "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc",
114       "0x051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef10"
115       "9e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00",
116       "0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
117       "ffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409",
118
119       "0xc6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3d"
120       "baa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66",
121       "0x11839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e6"
122       "62c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650"
123     },
124     {
125       "Ed25519",
126       "0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFED",
127       "-0x01",
128       "-0x2DFC9311D490018C7338BF8688861767FF8FF5B2BEBE27548A14B235ECA6874A",
129       "0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED",
130       "0x216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A",
131       "0x6666666666666666666666666666666666666666666666666666666666666658"
132     },
133     { NULL, NULL, NULL, NULL, NULL }
134   };
135
136 /* A sample public key for NIST P-256.  */
137 static const char sample_p256_q[] =
138   "04"
139   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E"
140   "E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
141 static const char sample_p256_q_x[] =
142   "42B927242237639A36CE9221B340DB1A9AB76DF2FE3E171277F6A4023DED146E";
143 static const char sample_p256_q_y[] =
144   "00E86525E38CCECFF3FB8D152CC6334F70D23A525175C1BCBDDE6E023B2228770E";
145
146
147 /* A sample public key for Ed25519.  */
148 static const char sample_ed25519_q[] =
149   "04"
150   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce"
151   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
152 static const char sample_ed25519_q_x[] =
153   "55d0e09a2b9d34292297e08d60d0f620c513d47253187c24b12786bd777645ce";
154 static const char sample_ed25519_q_y[] =
155   "1a5107f7681a02af2523a6daf372e10e3a0764c9d3fe4bd5b70ab18201985ad7";
156 static const char sample_ed25519_q_eddsa[] =
157   "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a";
158 static const char sample_ed25519_d[] =
159   "9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60";
160
161
162 static void
163 show (const char *format, ...)
164 {
165   va_list arg_ptr;
166
167   if (!verbose)
168     return;
169   fprintf (stderr, "%s: ", PGM);
170   va_start (arg_ptr, format);
171   vfprintf (stderr, format, arg_ptr);
172   va_end (arg_ptr);
173 }
174
175 static void
176 fail (const char *format, ...)
177 {
178   va_list arg_ptr;
179
180   fflush (stdout);
181   fprintf (stderr, "%s: ", PGM);
182   if (wherestr)
183     fprintf (stderr, "%s: ", wherestr);
184   va_start (arg_ptr, format);
185   vfprintf (stderr, format, arg_ptr);
186   va_end (arg_ptr);
187   error_count++;
188 }
189
190 static void
191 die (const char *format, ...)
192 {
193   va_list arg_ptr;
194
195   fflush (stdout);
196   fprintf (stderr, "%s: ", PGM);
197   if (wherestr)
198     fprintf (stderr, "%s: ", wherestr);
199   va_start (arg_ptr, format);
200   vfprintf (stderr, format, arg_ptr);
201   va_end (arg_ptr);
202   exit (1);
203 }
204
205
206 static void
207 print_mpi_2 (const char *text, const char *text2, gcry_mpi_t a)
208 {
209   gcry_error_t err;
210   char *buf;
211   void *bufaddr = &buf;
212
213   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
214   if (err)
215     fprintf (stderr, "%s%s: [error printing number: %s]\n",
216              text, text2? text2:"", gpg_strerror (err));
217   else
218     {
219       fprintf (stderr, "%s%s: %s\n", text, text2? text2:"", buf);
220       gcry_free (buf);
221     }
222 }
223
224
225 static void
226 print_mpi (const char *text, gcry_mpi_t a)
227 {
228   print_mpi_2 (text, NULL, a);
229 }
230
231
232 static void
233 print_point (const char *text, gcry_mpi_point_t a)
234 {
235   gcry_mpi_t x, y, z;
236
237   x = gcry_mpi_new (0);
238   y = gcry_mpi_new (0);
239   z = gcry_mpi_new (0);
240   gcry_mpi_point_get (x, y, z, a);
241   print_mpi_2 (text, ".x", x);
242   print_mpi_2 (text, ".y", y);
243   print_mpi_2 (text, ".z", z);
244   gcry_mpi_release (x);
245   gcry_mpi_release (y);
246   gcry_mpi_release (z);
247 }
248
249
250 static void
251 print_sexp (const char *prefix, gcry_sexp_t a)
252 {
253   char *buf;
254   size_t size;
255
256   if (prefix)
257     fputs (prefix, stderr);
258   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
259   buf = gcry_xmalloc (size);
260
261   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
262   fprintf (stderr, "%.*s", (int)size, buf);
263   gcry_free (buf);
264 }
265
266
267 static gcry_mpi_t
268 hex2mpi (const char *string)
269 {
270   gpg_error_t err;
271   gcry_mpi_t val;
272
273   err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
274   if (err)
275     die ("hex2mpi '%s' failed: %s\n", string, gpg_strerror (err));
276   return val;
277 }
278
279
280 /* Convert STRING consisting of hex characters into its binary
281    representation and return it as an allocated buffer. The valid
282    length of the buffer is returned at R_LENGTH.  The string is
283    delimited by end of string.  The function returns NULL on
284    error.  */
285 static void *
286 hex2buffer (const char *string, size_t *r_length)
287 {
288   const char *s;
289   unsigned char *buffer;
290   size_t length;
291
292   buffer = xmalloc (strlen(string)/2+1);
293   length = 0;
294   for (s=string; *s; s +=2 )
295     {
296       if (!hexdigitp (s) || !hexdigitp (s+1))
297         return NULL;           /* Invalid hex digits. */
298       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
299     }
300   *r_length = length;
301   return buffer;
302 }
303
304
305 static gcry_mpi_t
306 hex2mpiopa (const char *string)
307 {
308   char *buffer;
309   size_t buflen;
310   gcry_mpi_t val;
311
312   buffer = hex2buffer (string, &buflen);
313   if (!buffer)
314     die ("hex2mpiopa '%s' failed: parser error\n", string);
315   val = gcry_mpi_set_opaque (NULL, buffer, buflen*8);
316   if (!buffer)
317     die ("hex2mpiopa '%s' failed: set_opaque error%s\n", string);
318   return val;
319 }
320
321
322 /* Compare A to B, where B is given as a hex string.  */
323 static int
324 cmp_mpihex (gcry_mpi_t a, const char *b)
325 {
326   gcry_mpi_t bval;
327   int res;
328
329   if (gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE))
330     bval = hex2mpiopa (b);
331   else
332     bval = hex2mpi (b);
333   res = gcry_mpi_cmp (a, bval);
334   gcry_mpi_release (bval);
335   return res;
336 }
337
338
339 /* Wrapper to emulate the libgcrypt internal EC context allocation
340    function.  */
341 static gpg_error_t
342 ec_p_new (gcry_ctx_t *r_ctx, gcry_mpi_t p, gcry_mpi_t a)
343 {
344   gpg_error_t err;
345   gcry_sexp_t sexp;
346
347   if (p && a)
348     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m)(a %m))", p, a);
349   else if (p)
350     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (p %m))", p);
351   else if (a)
352     err = gcry_sexp_build (&sexp, NULL, "(ecdsa (a %m))", a);
353   else
354     err = gcry_sexp_build (&sexp, NULL, "(ecdsa)");
355   if (err)
356     return err;
357   err = gcry_mpi_ec_new (r_ctx, sexp, NULL);
358   gcry_sexp_release (sexp);
359   return err;
360 }
361
362
363 \f
364 static void
365 set_get_point (void)
366 {
367   gcry_mpi_point_t point;
368   gcry_mpi_t x, y, z;
369
370   wherestr = "set_get_point";
371   show ("checking point setting functions\n");
372
373   point = gcry_mpi_point_new (0);
374   x = gcry_mpi_set_ui (NULL, 17);
375   y = gcry_mpi_set_ui (NULL, 42);
376   z = gcry_mpi_set_ui (NULL, 11371);
377   gcry_mpi_point_get (x, y, z, point);
378   if (gcry_mpi_cmp_ui (x, 0)
379       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
380     fail ("new point not initialized to (0,0,0)\n");
381   gcry_mpi_point_snatch_get (x, y, z, point);
382   point = NULL;
383   if (gcry_mpi_cmp_ui (x, 0)
384       || gcry_mpi_cmp_ui (y, 0) || gcry_mpi_cmp_ui (z, 0))
385     fail ("snatch_get failed\n");
386   gcry_mpi_release (x);
387   gcry_mpi_release (y);
388   gcry_mpi_release (z);
389
390   point = gcry_mpi_point_new (0);
391   x = gcry_mpi_set_ui (NULL, 17);
392   y = gcry_mpi_set_ui (NULL, 42);
393   z = gcry_mpi_set_ui (NULL, 11371);
394   gcry_mpi_point_set (point, x, y, z);
395   gcry_mpi_set_ui (x, 23);
396   gcry_mpi_set_ui (y, 24);
397   gcry_mpi_set_ui (z, 25);
398   gcry_mpi_point_get (x, y, z, point);
399   if (gcry_mpi_cmp_ui (x, 17)
400       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
401     fail ("point_set/point_get failed\n");
402   gcry_mpi_point_snatch_set (point, x, y, z);
403   x = gcry_mpi_new (0);
404   y = gcry_mpi_new (0);
405   z = gcry_mpi_new (0);
406   gcry_mpi_point_get (x, y, z, point);
407   if (gcry_mpi_cmp_ui (x, 17)
408       || gcry_mpi_cmp_ui (y, 42) || gcry_mpi_cmp_ui (z, 11371))
409     fail ("point_snatch_set/point_get failed\n");
410
411   gcry_mpi_point_release (point);
412   gcry_mpi_release (x);
413   gcry_mpi_release (y);
414   gcry_mpi_release (z);
415 }
416
417
418 static void
419 context_alloc (void)
420 {
421   gpg_error_t err;
422   gcry_ctx_t ctx;
423   gcry_mpi_t p, a;
424
425   wherestr = "context_alloc";
426   show ("checking context functions\n");
427
428   p = gcry_mpi_set_ui (NULL, 1);
429   a = gcry_mpi_set_ui (NULL, 1);
430   err = ec_p_new (&ctx, p, a);
431   if (err)
432     die ("ec_p_new returned an error: %s\n", gpg_strerror (err));
433   gcry_mpi_release (p);
434   gcry_mpi_release (a);
435   gcry_ctx_release (ctx);
436
437   p = NULL;
438   a = gcry_mpi_set_ui (NULL, 0);
439
440   err = ec_p_new (&ctx, p, a);
441   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
442     fail ("ec_p_new: bad parameter detection failed (1)\n");
443
444   gcry_mpi_release (a);
445   a = NULL;
446   err = ec_p_new (&ctx, p, a);
447   if (!err || gpg_err_code (err) != GPG_ERR_EINVAL)
448     fail ("ec_p_new: bad parameter detection failed (2)\n");
449
450 }
451
452
453 static int
454 get_and_cmp_mpi (const char *name, const char *mpistring, const char *desc,
455                  gcry_ctx_t ctx)
456 {
457   gcry_mpi_t mpi;
458
459   mpi = gcry_mpi_ec_get_mpi (name, ctx, 1);
460   if (!mpi)
461     {
462       fail ("error getting parameter '%s' of curve '%s'\n", name, desc);
463       return 1;
464     }
465   if (debug)
466     print_mpi (name, mpi);
467   if (cmp_mpihex (mpi, mpistring))
468     {
469       fail ("parameter '%s' of curve '%s' does not match\n", name, desc);
470       gcry_mpi_release (mpi);
471       return 1;
472     }
473   gcry_mpi_release (mpi);
474   return 0;
475 }
476
477
478 static int
479 get_and_cmp_point (const char *name,
480                    const char *mpi_x_string, const char *mpi_y_string,
481                    const char *desc, gcry_ctx_t ctx)
482 {
483   gcry_mpi_point_t point;
484   gcry_mpi_t x, y, z;
485   int result = 0;
486
487   point = gcry_mpi_ec_get_point (name, ctx, 1);
488   if (!point)
489     {
490       fail ("error getting point parameter '%s' of curve '%s'\n", name, desc);
491       return 1;
492     }
493   if (debug)
494     print_point (name, point);
495
496   x = gcry_mpi_new (0);
497   y = gcry_mpi_new (0);
498   z = gcry_mpi_new (0);
499   gcry_mpi_point_snatch_get (x, y, z, point);
500   if (cmp_mpihex (x, mpi_x_string))
501     {
502       fail ("x coordinate of '%s' of curve '%s' does not match\n", name, desc);
503       result = 1;
504     }
505   if (cmp_mpihex (y, mpi_y_string))
506     {
507       fail ("y coordinate of '%s' of curve '%s' does not match\n", name, desc);
508       result = 1;
509     }
510   if (cmp_mpihex (z, "01"))
511     {
512       fail ("z coordinate of '%s' of curve '%s' is not 1\n", name, desc);
513       result = 1;
514     }
515   gcry_mpi_release (x);
516   gcry_mpi_release (y);
517   gcry_mpi_release (z);
518   return result;
519 }
520
521
522 static void
523 context_param (void)
524 {
525   gpg_error_t err;
526   int idx;
527   gcry_ctx_t ctx = NULL;
528   gcry_mpi_t q, d;
529   gcry_sexp_t keyparam;
530
531   wherestr = "context_param";
532
533   show ("checking standard curves\n");
534   for (idx=0; test_curve[idx].desc; idx++)
535     {
536       gcry_ctx_release (ctx);
537       err = gcry_mpi_ec_new (&ctx, NULL, test_curve[idx].desc);
538       if (err)
539         {
540           fail ("can't create context for curve '%s': %s\n",
541                 test_curve[idx].desc, gpg_strerror (err));
542           continue;
543         }
544       if (get_and_cmp_mpi ("p", test_curve[idx].p, test_curve[idx].desc, ctx))
545         continue;
546       if (get_and_cmp_mpi ("a", test_curve[idx].a, test_curve[idx].desc, ctx))
547         continue;
548       if (get_and_cmp_mpi ("b", test_curve[idx].b, test_curve[idx].desc, ctx))
549         continue;
550       if (get_and_cmp_mpi ("g.x",test_curve[idx].g_x, test_curve[idx].desc,ctx))
551         continue;
552       if (get_and_cmp_mpi ("g.y",test_curve[idx].g_y, test_curve[idx].desc,ctx))
553         continue;
554       if (get_and_cmp_mpi ("n", test_curve[idx].n, test_curve[idx].desc, ctx))
555         continue;
556       if (get_and_cmp_point ("g", test_curve[idx].g_x, test_curve[idx].g_y,
557                              test_curve[idx].desc, ctx))
558         continue;
559
560     }
561
562   show ("checking sample public key (nistp256)\n");
563   q = hex2mpi (sample_p256_q);
564   err = gcry_sexp_build (&keyparam, NULL,
565                         "(public-key(ecc(curve %s)(q %m)))",
566                         "NIST P-256", q);
567   if (err)
568     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
569   gcry_mpi_release (q);
570
571   /* We can't call gcry_pk_testkey because it is only implemented for
572      private keys.  */
573   /* err = gcry_pk_testkey (keyparam); */
574   /* if (err) */
575   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
576   /*         gpg_strerror (err)); */
577
578   gcry_ctx_release (ctx);
579   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
580   if (err)
581     fail ("gcry_mpi_ec_new failed for sample public key (nistp256): %s\n",
582           gpg_strerror (err));
583   else
584     {
585       gcry_sexp_t sexp;
586
587       get_and_cmp_mpi ("q", sample_p256_q, "nistp256", ctx);
588       get_and_cmp_point ("q", sample_p256_q_x, sample_p256_q_y, "nistp256",
589                          ctx);
590
591       /* Delete Q.  */
592       err = gcry_mpi_ec_set_mpi ("q", NULL, ctx);
593       if (err)
594         fail ("clearing Q for nistp256 failed: %s\n", gpg_strerror (err));
595       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
596         fail ("clearing Q for nistp256 did not work\n");
597
598       /* Set Q again.  */
599       q = hex2mpi (sample_p256_q);
600       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
601       if (err)
602         fail ("setting Q for nistp256 failed: %s\n", gpg_strerror (err));
603       get_and_cmp_mpi ("q", sample_p256_q, "nistp256(2)", ctx);
604       gcry_mpi_release (q);
605
606       /* Get as s-expression.  */
607       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
608       if (err)
609         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
610       else if (debug)
611         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
612       gcry_sexp_release (sexp);
613
614       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
615       if (err)
616         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
617               gpg_strerror (err));
618       else if (debug)
619         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
620       gcry_sexp_release (sexp);
621
622       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
623       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
624         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
625               gpg_strerror (err));
626       gcry_sexp_release (sexp);
627     }
628
629   show ("checking sample public key (Ed25519)\n");
630   q = hex2mpi (sample_ed25519_q);
631   gcry_sexp_release (keyparam);
632   err = gcry_sexp_build (&keyparam, NULL,
633                         "(public-key(ecc(curve %s)(flags eddsa)(q %m)))",
634                         "Ed25519", q);
635   if (err)
636     die ("gcry_sexp_build failed: %s\n", gpg_strerror (err));
637   gcry_mpi_release (q);
638
639   /* We can't call gcry_pk_testkey because it is only implemented for
640      private keys.  */
641   /* err = gcry_pk_testkey (keyparam); */
642   /* if (err) */
643   /*   fail ("gcry_pk_testkey failed for sample public key: %s\n", */
644   /*         gpg_strerror (err)); */
645
646   gcry_ctx_release (ctx);
647   err = gcry_mpi_ec_new (&ctx, keyparam, NULL);
648   if (err)
649     fail ("gcry_mpi_ec_new failed for sample public key: %s\n",
650           gpg_strerror (err));
651   else
652     {
653       gcry_sexp_t sexp;
654
655       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519", ctx);
656       get_and_cmp_point ("q", sample_ed25519_q_x, sample_ed25519_q_y,
657                          "Ed25519", ctx);
658       get_and_cmp_mpi ("q@eddsa", sample_ed25519_q_eddsa, "Ed25519", ctx);
659
660       /* Set d to see whether Q is correctly re-computed.  */
661       d = hex2mpi (sample_ed25519_d);
662       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
663       if (err)
664         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
665       gcry_mpi_release (d);
666       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(recompute Q)", ctx);
667
668       /* Delete Q by setting d and then clearing d.  The clearing is
669          required so that we can check whether Q has been cleared and
670          because further tests only expect a public key.  */
671       d = hex2mpi (sample_ed25519_d);
672       err = gcry_mpi_ec_set_mpi ("d", d, ctx);
673       if (err)
674         fail ("setting d for Ed25519 failed: %s\n", gpg_strerror (err));
675       gcry_mpi_release (d);
676       err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
677       if (err)
678         fail ("setting d for Ed25519 failed(2): %s\n", gpg_strerror (err));
679       if (gcry_mpi_ec_get_mpi ("q", ctx, 0))
680         fail ("setting d for Ed25519 did not reset Q\n");
681
682       /* Set Q again.  We need to use an opaque MPI here because
683          sample_ed25519_q is in uncompressed format which can only be
684          auto-detected if passed opaque.  */
685       q = hex2mpiopa (sample_ed25519_q);
686       err = gcry_mpi_ec_set_mpi ("q", q, ctx);
687       if (err)
688         fail ("setting Q for Ed25519 failed: %s\n", gpg_strerror (err));
689       gcry_mpi_release (q);
690       get_and_cmp_mpi ("q", sample_ed25519_q, "Ed25519(2)", ctx);
691
692       /* Get as s-expression.  */
693       err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
694       if (err)
695         fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
696       else if (debug)
697         print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
698       gcry_sexp_release (sexp);
699
700       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
701       if (err)
702         fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n",
703               gpg_strerror (err));
704       else if (debug)
705         print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
706       gcry_sexp_release (sexp);
707
708       err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
709       if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
710         fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
711               gpg_strerror (err));
712       gcry_sexp_release (sexp);
713
714     }
715
716   gcry_ctx_release (ctx);
717   gcry_sexp_release (keyparam);
718 }
719
720
721
722
723 /* Create a new point from (X,Y,Z) given as hex strings.  */
724 gcry_mpi_point_t
725 make_point (const char *x, const char *y, const char *z)
726 {
727   gcry_mpi_point_t point;
728
729   point = gcry_mpi_point_new (0);
730   gcry_mpi_point_snatch_set (point, hex2mpi (x), hex2mpi (y), hex2mpi (z));
731
732   return point;
733 }
734
735
736 /* This tests checks that the low-level EC API yields the same result
737    as using the high level API.  The values have been taken from a
738    test run using the high level API.  */
739 static void
740 basic_ec_math (void)
741 {
742   gpg_error_t err;
743   gcry_ctx_t ctx;
744   gcry_mpi_t P, A;
745   gcry_mpi_point_t G, Q;
746   gcry_mpi_t d;
747   gcry_mpi_t x, y, z;
748
749   wherestr = "basic_ec_math";
750   show ("checking basic math functions for EC\n");
751
752   P = hex2mpi ("0xfffffffffffffffffffffffffffffffeffffffffffffffff");
753   A = hex2mpi ("0xfffffffffffffffffffffffffffffffefffffffffffffffc");
754   G = make_point ("188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012",
755                   "7192B95FFC8DA78631011ED6B24CDD573F977A11E794811",
756                   "1");
757   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
758   Q = gcry_mpi_point_new (0);
759
760   err = ec_p_new (&ctx, P, A);
761   if (err)
762     die ("ec_p_new failed: %s\n", gpg_strerror (err));
763
764   x = gcry_mpi_new (0);
765   y = gcry_mpi_new (0);
766   z = gcry_mpi_new (0);
767
768   {
769     /* A quick check that multiply by zero works.  */
770     gcry_mpi_t tmp;
771
772     tmp = gcry_mpi_new (0);
773     gcry_mpi_ec_mul (Q, tmp, G, ctx);
774     gcry_mpi_release (tmp);
775     gcry_mpi_point_get (x, y, z, Q);
776     if (gcry_mpi_cmp_ui (x, 0) || gcry_mpi_cmp_ui (y, 0)
777         || gcry_mpi_cmp_ui (z, 0))
778       fail ("multiply a point by zero failed\n");
779   }
780
781   gcry_mpi_ec_mul (Q, d, G, ctx);
782   gcry_mpi_point_get (x, y, z, Q);
783   if (cmp_mpihex (x, "222D9EC717C89D047E0898C9185B033CD11C0A981EE6DC66")
784       || cmp_mpihex (y, "605DE0A82D70D3E0F84A127D0739ED33D657DF0D054BFDE8")
785       || cmp_mpihex (z, "00B06B519071BC536999AC8F2D3934B3C1FC9EACCD0A31F88F"))
786     fail ("computed public key does not match\n");
787   if (debug)
788     {
789       print_mpi ("Q.x", x);
790       print_mpi ("Q.y", y);
791       print_mpi ("Q.z", z);
792     }
793
794   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
795     fail ("failed to get affine coordinates\n");
796   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
797       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
798     fail ("computed affine coordinates of public key do not match\n");
799   if (debug)
800     {
801       print_mpi ("q.x", x);
802       print_mpi ("q.y", y);
803     }
804
805   gcry_mpi_release (z);
806   gcry_mpi_release (y);
807   gcry_mpi_release (x);
808   gcry_mpi_point_release (Q);
809   gcry_mpi_release (d);
810   gcry_mpi_point_release (G);
811   gcry_mpi_release (A);
812   gcry_mpi_release (P);
813   gcry_ctx_release (ctx);
814 }
815
816
817 /* This is the same as basic_ec_math but uses more advanced
818    features.  */
819 static void
820 basic_ec_math_simplified (void)
821 {
822   gpg_error_t err;
823   gcry_ctx_t ctx;
824   gcry_mpi_point_t G, Q;
825   gcry_mpi_t d;
826   gcry_mpi_t x, y, z;
827   gcry_sexp_t sexp;
828
829   wherestr = "basic_ec_math_simplified";
830   show ("checking basic math functions for EC (variant)\n");
831
832   d = hex2mpi ("D4EF27E32F8AD8E2A1C6DDEBB1D235A69E3CEF9BCE90273D");
833   Q = gcry_mpi_point_new (0);
834
835   err = gcry_mpi_ec_new (&ctx, NULL, "NIST P-192");
836   if (err)
837     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
838   G = gcry_mpi_ec_get_point ("g", ctx, 1);
839   if (!G)
840     die ("gcry_mpi_ec_get_point(G) failed\n");
841   gcry_mpi_ec_mul (Q, d, G, ctx);
842
843   x = gcry_mpi_new (0);
844   y = gcry_mpi_new (0);
845   z = gcry_mpi_new (0);
846   gcry_mpi_point_get (x, y, z, Q);
847   if (cmp_mpihex (x, "222D9EC717C89D047E0898C9185B033CD11C0A981EE6DC66")
848       || cmp_mpihex (y, "605DE0A82D70D3E0F84A127D0739ED33D657DF0D054BFDE8")
849       || cmp_mpihex (z, "00B06B519071BC536999AC8F2D3934B3C1FC9EACCD0A31F88F"))
850     fail ("computed public key does not match\n");
851   if (debug)
852     {
853       print_mpi ("Q.x", x);
854       print_mpi ("Q.y", y);
855       print_mpi ("Q.z", z);
856     }
857
858   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
859     fail ("failed to get affine coordinates\n");
860   if (cmp_mpihex (x, "008532093BA023F4D55C0424FA3AF9367E05F309DC34CDC3FE")
861       || cmp_mpihex (y, "00C13CA9E617C6C8487BFF6A726E3C4F277913D97117939966"))
862     fail ("computed affine coordinates of public key do not match\n");
863   if (debug)
864     {
865       print_mpi ("q.x", x);
866       print_mpi ("q.y", y);
867     }
868
869   gcry_mpi_release (z);
870   gcry_mpi_release (y);
871   gcry_mpi_release (x);
872
873   /* Let us also check whether we can update the context.  */
874   err = gcry_mpi_ec_set_point ("g", G, ctx);
875   if (err)
876     die ("gcry_mpi_ec_set_point(G) failed\n");
877   err = gcry_mpi_ec_set_mpi ("d", d, ctx);
878   if (err)
879     die ("gcry_mpi_ec_set_mpi(d) failed\n");
880
881   /* FIXME: Below we need to check that the returned S-expression is
882      as requested.  For now we use manual inspection using --debug.  */
883
884   /* Does get_sexp return the private key?  */
885   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
886   if (err)
887     fail ("gcry_pubkey_get_sexp(0) failed: %s\n", gpg_strerror (err));
888   else if (debug)
889     print_sexp ("Result of gcry_pubkey_get_sexp (0):\n", sexp);
890   gcry_sexp_release (sexp);
891
892   /* Does get_sexp return the public key if requested?  */
893   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_PUBKEY, ctx);
894   if (err)
895     fail ("gcry_pubkey_get_sexp(GET_PUBKEY) failed: %s\n", gpg_strerror (err));
896   else if (debug)
897     print_sexp ("Result of gcry_pubkey_get_sexp (GET_PUBKEY):\n", sexp);
898   gcry_sexp_release (sexp);
899
900   /* Does get_sexp return the public key after d has been deleted?  */
901   err = gcry_mpi_ec_set_mpi ("d", NULL, ctx);
902   if (err)
903     die ("gcry_mpi_ec_set_mpi(d=NULL) failed\n");
904   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
905   if (err)
906     fail ("gcry_pubkey_get_sexp(0 w/o d) failed: %s\n", gpg_strerror (err));
907   else if (debug)
908     print_sexp ("Result of gcry_pubkey_get_sexp (0 w/o d):\n", sexp);
909   gcry_sexp_release (sexp);
910
911   /* Does get_sexp return an error after d has been deleted?  */
912   err = gcry_pubkey_get_sexp (&sexp, GCRY_PK_GET_SECKEY, ctx);
913   if (gpg_err_code (err) != GPG_ERR_NO_SECKEY)
914     fail ("gcry_pubkey_get_sexp(GET_SECKEY) returned wrong error: %s\n",
915           gpg_strerror (err));
916   gcry_sexp_release (sexp);
917
918   /* Does get_sexp return an error after d and Q have been deleted?  */
919   err = gcry_mpi_ec_set_point ("q", NULL, ctx);
920   if (err)
921     die ("gcry_mpi_ec_set_point(q=NULL) failed\n");
922   err = gcry_pubkey_get_sexp (&sexp, 0, ctx);
923   if (gpg_err_code (err) != GPG_ERR_BAD_CRYPT_CTX)
924     fail ("gcry_pubkey_get_sexp(0 w/o Q,d) returned wrong error: %s\n",
925           gpg_strerror (err));
926   gcry_sexp_release (sexp);
927
928
929   gcry_mpi_point_release (Q);
930   gcry_mpi_release (d);
931   gcry_mpi_point_release (G);
932   gcry_ctx_release (ctx);
933 }
934
935
936 /* Check the math used with Twisted Edwards curves.  */
937 static void
938 twistededwards_math (void)
939 {
940   gpg_error_t err;
941   gcry_ctx_t ctx;
942   gcry_mpi_point_t G, Q;
943   gcry_mpi_t k;
944   gcry_mpi_t w, a, x, y, z, p, n, b, I;
945
946   wherestr = "twistededwards_math";
947   show ("checking basic Twisted Edwards math\n");
948
949   err = gcry_mpi_ec_new (&ctx, NULL, "Ed25519");
950   if (err)
951     die ("gcry_mpi_ec_new failed: %s\n", gpg_strerror (err));
952
953   k = hex2mpi
954     ("2D3501E723239632802454EE5DDC406EFB0BDF18486A5BDE9C0390A9C2984004"
955      "F47252B628C953625B8DEB5DBCB8DA97AA43A1892D11FA83596F42E0D89CB1B6");
956   G = gcry_mpi_ec_get_point ("g", ctx, 1);
957   if (!G)
958     die ("gcry_mpi_ec_get_point(G) failed\n");
959   Q = gcry_mpi_point_new (0);
960
961
962   w = gcry_mpi_new (0);
963   a = gcry_mpi_new (0);
964   x = gcry_mpi_new (0);
965   y = gcry_mpi_new (0);
966   z = gcry_mpi_new (0);
967   I = gcry_mpi_new (0);
968   p = gcry_mpi_ec_get_mpi ("p", ctx, 1);
969   n = gcry_mpi_ec_get_mpi ("n", ctx, 1);
970   b = gcry_mpi_ec_get_mpi ("b", ctx, 1);
971
972   /* Check: 2^{p-1} mod p == 1 */
973   gcry_mpi_sub_ui (a, p, 1);
974   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, p);
975   if (gcry_mpi_cmp_ui (w, 1))
976     fail ("failed assertion: 2^{p-1} mod p == 1\n");
977
978   /* Check: p % 4 == 1 */
979   gcry_mpi_mod (w, p, GCRYMPI_CONST_FOUR);
980   if (gcry_mpi_cmp_ui (w, 1))
981     fail ("failed assertion: p % 4 == 1\n");
982
983   /* Check: 2^{n-1} mod n == 1 */
984   gcry_mpi_sub_ui (a, n, 1);
985   gcry_mpi_powm (w, GCRYMPI_CONST_TWO, a, n);
986   if (gcry_mpi_cmp_ui (w, 1))
987     fail ("failed assertion: 2^{n-1} mod n == 1\n");
988
989   /* Check: b^{(p-1)/2} mod p == p-1 */
990   gcry_mpi_sub_ui (a, p, 1);
991   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_TWO, -1);
992   gcry_mpi_powm (w, b, x, p);
993   gcry_mpi_abs (w);
994   if (gcry_mpi_cmp (w, a))
995     fail ("failed assertion: b^{(p-1)/2} mod p == p-1\n");
996
997   /* I := 2^{(p-1)/4} mod p */
998   gcry_mpi_sub_ui (a, p, 1);
999   gcry_mpi_div (x, NULL, a, GCRYMPI_CONST_FOUR, -1);
1000   gcry_mpi_powm (I, GCRYMPI_CONST_TWO, x, p);
1001
1002   /* Check: I^2 mod p == p-1 */
1003   gcry_mpi_powm (w, I, GCRYMPI_CONST_TWO, p);
1004   if (gcry_mpi_cmp (w, a))
1005     fail ("failed assertion: I^2 mod p == p-1\n");
1006
1007   /* Check: G is on the curve */
1008   if (!gcry_mpi_ec_curve_point (G, ctx))
1009     fail ("failed assertion: G is on the curve\n");
1010
1011   /* Check: nG == (0,1) */
1012   gcry_mpi_ec_mul (Q, n, G, ctx);
1013   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
1014     fail ("failed to get affine coordinates\n");
1015   if (gcry_mpi_cmp_ui (x, 0) || gcry_mpi_cmp_ui (y, 1))
1016     fail ("failed assertion: nG == (0,1)\n");
1017
1018   /* Now two arbitrary point operations taken from the ed25519.py
1019      sample data.  */
1020   gcry_mpi_release (a);
1021   a = hex2mpi
1022     ("4f71d012df3c371af3ea4dc38385ca5bb7272f90cb1b008b3ed601c76de1d496"
1023      "e30cbf625f0a756a678d8f256d5325595cccc83466f36db18f0178eb9925edd3");
1024   gcry_mpi_ec_mul (Q, a, G, ctx);
1025   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
1026     fail ("failed to get affine coordinates\n");
1027   if (cmp_mpihex (x, ("157f7361c577aad36f67ed33e38dc7be"
1028                       "00014fecc2165ca5cee9eee19fe4d2c1"))
1029       || cmp_mpihex (y, ("5a69dbeb232276b38f3f5016547bb2a2"
1030                          "4025645f0b820e72b8cad4f0a909a092")))
1031     {
1032       fail ("sample point multiply failed:\n");
1033       print_mpi ("r", a);
1034       print_mpi ("Rx", x);
1035       print_mpi ("Ry", y);
1036     }
1037
1038   gcry_mpi_release (a);
1039   a = hex2mpi
1040     ("2d3501e723239632802454ee5ddc406efb0bdf18486a5bde9c0390a9c2984004"
1041      "f47252b628c953625b8deb5dbcb8da97aa43a1892d11fa83596f42e0d89cb1b6");
1042   gcry_mpi_ec_mul (Q, a, G, ctx);
1043   if (gcry_mpi_ec_get_affine (x, y, Q, ctx))
1044     fail ("failed to get affine coordinates\n");
1045   if (cmp_mpihex (x, ("6218e309d40065fcc338b3127f468371"
1046                       "82324bd01ce6f3cf81ab44e62959c82a"))
1047       || cmp_mpihex (y, ("5501492265e073d874d9e5b81e7f8784"
1048                          "8a826e80cce2869072ac60c3004356e5")))
1049     {
1050       fail ("sample point multiply failed:\n");
1051       print_mpi ("r", a);
1052       print_mpi ("Rx", x);
1053       print_mpi ("Ry", y);
1054     }
1055
1056
1057   gcry_mpi_release (I);
1058   gcry_mpi_release (b);
1059   gcry_mpi_release (n);
1060   gcry_mpi_release (p);
1061   gcry_mpi_release (w);
1062   gcry_mpi_release (a);
1063   gcry_mpi_release (x);
1064   gcry_mpi_release (y);
1065   gcry_mpi_release (z);
1066   gcry_mpi_point_release (Q);
1067   gcry_mpi_point_release (G);
1068   gcry_mpi_release (k);
1069   gcry_ctx_release (ctx);
1070 }
1071
1072
1073 int
1074 main (int argc, char **argv)
1075 {
1076
1077   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1078     verbose = 1;
1079   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1080     verbose = debug = 1;
1081
1082   if (!gcry_check_version (GCRYPT_VERSION))
1083     die ("version mismatch\n");
1084
1085   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1086   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1087   if (debug)
1088     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
1089   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1090
1091   set_get_point ();
1092   context_alloc ();
1093   context_param ();
1094   basic_ec_math ();
1095   basic_ec_math_simplified ();
1096   twistededwards_math ();
1097
1098   show ("All tests completed. Errors: %d\n", error_count);
1099   return error_count ? 1 : 0;
1100 }