tests: Fixes for RSA testsuite in FIPS mode
[libgcrypt.git] / tests / pubkey.c
1 /* pubkey.c - Public key encryption/decryption tests
2  *      Copyright (C) 2001, 2002, 2003, 2005 Free Software Foundation, Inc.
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 <stdarg.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28
29 #include "../src/gcrypt-int.h"
30
31 #define my_isascii(c) (!((c) & 0x80))
32 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
33 #define hexdigitp(a) (digitp (a)                     \
34                       || (*(a) >= 'A' && *(a) <= 'F')  \
35                       || (*(a) >= 'a' && *(a) <= 'f'))
36 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
37                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
38 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
39 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
40 #define DIMof(type,member)   DIM(((type *)0)->member)
41
42
43 /* Sample RSA keys, taken from basic.c.  */
44
45 static const char sample_private_key_1[] =
46 "(private-key\n"
47 " (openpgp-rsa\n"
48 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
49       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
50       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
51       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
52 "  (e #010001#)\n"
53 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
54       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
55       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
56       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
57 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
58       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
59 "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
60       "35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
61 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
62       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
63 " )\n"
64 ")\n";
65
66 /* The same key as above but without p, q and u to test the non CRT case. */
67 static const char sample_private_key_1_1[] =
68 "(private-key\n"
69 " (openpgp-rsa\n"
70 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
71       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
72       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
73       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
74 "  (e #010001#)\n"
75 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
76       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
77       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
78       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
79 " )\n"
80 ")\n";
81
82 /* The same key as above but just without q to test the non CRT case.  This
83    should fail. */
84 static const char sample_private_key_1_2[] =
85 "(private-key\n"
86 " (openpgp-rsa\n"
87 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
88       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
89       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
90       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
91 "  (e #010001#)\n"
92 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
93       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
94       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
95       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
96 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
97       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
98 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
99       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
100 " )\n"
101 ")\n";
102
103 static const char sample_public_key_1[] =
104 "(public-key\n"
105 " (rsa\n"
106 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
107       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
108       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
109       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
110 "  (e #010001#)\n"
111 " )\n"
112 ")\n";
113
114
115 static int verbose;
116 static int error_count;
117
118 static void
119 die (const char *format, ...)
120 {
121   va_list arg_ptr ;
122
123   va_start( arg_ptr, format ) ;
124   vfprintf (stderr, format, arg_ptr );
125   va_end(arg_ptr);
126   if (*format && format[strlen(format)-1] != '\n')
127     putc ('\n', stderr);
128   exit (1);
129 }
130
131 static void
132 fail (const char *format, ...)
133 {
134   va_list arg_ptr;
135
136   va_start (arg_ptr, format);
137   vfprintf (stderr, format, arg_ptr);
138   va_end (arg_ptr);
139   error_count++;
140 }
141
142 static void
143 info (const char *format, ...)
144 {
145   va_list arg_ptr;
146
147   va_start (arg_ptr, format);
148   vfprintf (stderr, format, arg_ptr);
149   va_end (arg_ptr);
150 }
151
152 static void
153 show_sexp (const char *prefix, gcry_sexp_t a)
154 {
155   char *buf;
156   size_t size;
157
158   if (prefix)
159     fputs (prefix, stderr);
160   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
161   buf = gcry_xmalloc (size);
162
163   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
164   fprintf (stderr, "%.*s", (int)size, buf);
165   gcry_free (buf);
166 }
167
168 /* from ../cipher/pubkey-util.c */
169 gpg_err_code_t
170 _gcry_pk_util_get_nbits (gcry_sexp_t list, unsigned int *r_nbits)
171 {
172   char buf[50];
173   const char *s;
174   size_t n;
175
176   *r_nbits = 0;
177
178   list = gcry_sexp_find_token (list, "nbits", 0);
179   if (!list)
180     return 0; /* No NBITS found.  */
181
182   s = gcry_sexp_nth_data (list, 1, &n);
183   if (!s || n >= DIM (buf) - 1 )
184     {
185       /* NBITS given without a cdr.  */
186       gcry_sexp_release (list);
187       return GPG_ERR_INV_OBJ;
188     }
189   memcpy (buf, s, n);
190   buf[n] = 0;
191   *r_nbits = (unsigned int)strtoul (buf, NULL, 0);
192   gcry_sexp_release (list);
193   return 0;
194 }
195
196 /* Convert STRING consisting of hex characters into its binary
197    representation and return it as an allocated buffer. The valid
198    length of the buffer is returned at R_LENGTH.  The string is
199    delimited by end of string.  The function returns NULL on
200    error.  */
201 static void *
202 data_from_hex (const char *string, size_t *r_length)
203 {
204   const char *s;
205   unsigned char *buffer;
206   size_t length;
207
208   buffer = gcry_xmalloc (strlen(string)/2+1);
209   length = 0;
210   for (s=string; *s; s +=2 )
211     {
212       if (!hexdigitp (s) || !hexdigitp (s+1))
213         die ("error parsing hex string `%s'\n", string);
214       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
215     }
216   *r_length = length;
217   return buffer;
218 }
219
220
221 static void
222 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected)
223 {
224   gcry_sexp_t l1;
225   const void *a;
226   size_t alen;
227   void *b;
228   size_t blen;
229
230   l1 = gcry_sexp_find_token (sexp, name, 0);
231   a = gcry_sexp_nth_data (l1, 1, &alen);
232   b = data_from_hex (expected, &blen);
233   if (!a)
234     fail ("parameter \"%s\" missing in key\n", name);
235   else if ( alen != blen || memcmp (a, b, alen) )
236     {
237       fail ("parameter \"%s\" does not match expected value\n", name);
238       if (verbose)
239         {
240           info ("expected: %s\n", expected);
241           show_sexp ("sexp: ", sexp);
242         }
243     }
244   gcry_free (b);
245   gcry_sexp_release (l1);
246 }
247
248
249 static void
250 check_keys_crypt (gcry_sexp_t pkey, gcry_sexp_t skey,
251                   gcry_sexp_t plain0, gpg_err_code_t decrypt_fail_code)
252 {
253   gcry_sexp_t plain1, cipher, l;
254   gcry_mpi_t x0, x1;
255   int rc;
256   int have_flags;
257
258   /* Extract data from plaintext.  */
259   l = gcry_sexp_find_token (plain0, "value", 0);
260   x0 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
261   gcry_sexp_release (l);
262
263   /* Encrypt data.  */
264   rc = gcry_pk_encrypt (&cipher, plain0, pkey);
265   if (rc)
266     die ("encryption failed: %s\n", gcry_strerror (rc));
267
268   l = gcry_sexp_find_token (cipher, "flags", 0);
269   have_flags = !!l;
270   gcry_sexp_release (l);
271
272   /* Decrypt data.  */
273   rc = gcry_pk_decrypt (&plain1, cipher, skey);
274   gcry_sexp_release (cipher);
275   if (rc)
276     {
277       if (decrypt_fail_code && gpg_err_code (rc) == decrypt_fail_code)
278         {
279           gcry_mpi_release (x0);
280           return; /* This is the expected failure code.  */
281         }
282       die ("decryption failed: %s\n", gcry_strerror (rc));
283     }
284
285   /* Extract decrypted data.  Note that for compatibility reasons, the
286      output of gcry_pk_decrypt depends on whether a flags lists (even
287      if empty) occurs in its input data.  Because we passed the output
288      of encrypt directly to decrypt, such a flag value won't be there
289      as of today.  We check it anyway. */
290   l = gcry_sexp_find_token (plain1, "value", 0);
291   if (l)
292     {
293       if (!have_flags)
294         die ("compatibility mode of pk_decrypt broken\n");
295       gcry_sexp_release (plain1);
296       x1 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
297       gcry_sexp_release (l);
298     }
299   else
300     {
301       if (have_flags)
302         die ("compatibility mode of pk_decrypt broken\n");
303       x1 = gcry_sexp_nth_mpi (plain1, 0, GCRYMPI_FMT_USG);
304       gcry_sexp_release (plain1);
305     }
306
307   /* Compare.  */
308   if (gcry_mpi_cmp (x0, x1))
309     die ("data corrupted\n");
310   gcry_mpi_release (x0);
311   gcry_mpi_release (x1);
312 }
313
314 static void
315 check_keys (gcry_sexp_t pkey, gcry_sexp_t skey, unsigned int nbits_data,
316             gpg_err_code_t decrypt_fail_code)
317 {
318   gcry_sexp_t plain;
319   gcry_mpi_t x;
320   int rc;
321
322   /* Create plain text.  */
323   x = gcry_mpi_new (nbits_data);
324   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
325
326   rc = gcry_sexp_build (&plain, NULL, "(data (flags raw) (value %m))", x);
327   if (rc)
328     die ("converting data for encryption failed: %s\n",
329          gcry_strerror (rc));
330
331   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
332   gcry_sexp_release (plain);
333   gcry_mpi_release (x);
334
335   /* Create plain text.  */
336   x = gcry_mpi_new (nbits_data);
337   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
338
339   rc = gcry_sexp_build (&plain, NULL,
340                         "(data (flags raw no-blinding) (value %m))", x);
341   gcry_mpi_release (x);
342   if (rc)
343     die ("converting data for encryption failed: %s\n",
344          gcry_strerror (rc));
345
346   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
347   gcry_sexp_release (plain);
348 }
349
350 static void
351 get_keys_sample (gcry_sexp_t *pkey, gcry_sexp_t *skey, int secret_variant)
352 {
353   gcry_sexp_t pub_key, sec_key;
354   int rc;
355   static const char *secret;
356
357
358   switch (secret_variant)
359     {
360     case 0: secret = sample_private_key_1; break;
361     case 1: secret = sample_private_key_1_1; break;
362     case 2: secret = sample_private_key_1_2; break;
363     default: die ("BUG\n");
364     }
365
366   rc = gcry_sexp_sscan (&pub_key, NULL, sample_public_key_1,
367                         strlen (sample_public_key_1));
368   if (!rc)
369     rc = gcry_sexp_sscan (&sec_key, NULL, secret, strlen (secret));
370   if (rc)
371     die ("converting sample keys failed: %s\n", gcry_strerror (rc));
372
373   *pkey = pub_key;
374   *skey = sec_key;
375 }
376
377 static void
378 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
379 {
380   gcry_sexp_t key_spec, key, pub_key, sec_key;
381   int rc;
382
383   rc = gcry_sexp_new (&key_spec,
384                       "(genkey (rsa (nbits 4:2048)))", 0, 1);
385   if (rc)
386     die ("error creating S-expression: %s\n", gcry_strerror (rc));
387   rc = gcry_pk_genkey (&key, key_spec);
388   gcry_sexp_release (key_spec);
389   if (rc)
390     die ("error generating RSA key: %s\n", gcry_strerror (rc));
391
392   if (verbose > 1)
393     show_sexp ("generated RSA key:\n", key);
394
395   pub_key = gcry_sexp_find_token (key, "public-key", 0);
396   if (! pub_key)
397     die ("public part missing in key\n");
398
399   sec_key = gcry_sexp_find_token (key, "private-key", 0);
400   if (! sec_key)
401     die ("private part missing in key\n");
402
403   gcry_sexp_release (key);
404   *pkey = pub_key;
405   *skey = sec_key;
406 }
407
408
409 static void
410 get_keys_x931_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
411 {
412   gcry_sexp_t key_spec, key, pub_key, sec_key;
413   int rc;
414
415   rc = gcry_sexp_new (&key_spec,
416                       "(genkey (rsa (nbits 4:2048)(use-x931)))", 0, 1);
417   if (rc)
418     die ("error creating S-expression: %s\n", gcry_strerror (rc));
419   rc = gcry_pk_genkey (&key, key_spec);
420   gcry_sexp_release (key_spec);
421   if (rc)
422     die ("error generating RSA key: %s\n", gcry_strerror (rc));
423
424   if (verbose > 1)
425     show_sexp ("generated RSA (X9.31) key:\n", key);
426
427   pub_key = gcry_sexp_find_token (key, "public-key", 0);
428   if (!pub_key)
429     die ("public part missing in key\n");
430
431   sec_key = gcry_sexp_find_token (key, "private-key", 0);
432   if (!sec_key)
433     die ("private part missing in key\n");
434
435   gcry_sexp_release (key);
436   *pkey = pub_key;
437   *skey = sec_key;
438 }
439
440
441 static void
442 get_elg_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int fixed_x)
443 {
444   gcry_sexp_t key_spec, key, pub_key, sec_key;
445   int rc;
446
447   rc = gcry_sexp_new
448     (&key_spec,
449      (fixed_x
450       ? "(genkey (elg (nbits 4:1024)(xvalue my.not-so-secret.key)))"
451       : "(genkey (elg (nbits 3:512)))"),
452      0, 1);
453
454   if (rc)
455     die ("error creating S-expression: %s\n", gcry_strerror (rc));
456   rc = gcry_pk_genkey (&key, key_spec);
457   gcry_sexp_release (key_spec);
458   if (rc)
459     die ("error generating Elgamal key: %s\n", gcry_strerror (rc));
460
461   if (verbose > 1)
462     show_sexp ("generated ELG key:\n", key);
463
464   pub_key = gcry_sexp_find_token (key, "public-key", 0);
465   if (!pub_key)
466     die ("public part missing in key\n");
467
468   sec_key = gcry_sexp_find_token (key, "private-key", 0);
469   if (!sec_key)
470     die ("private part missing in key\n");
471
472   gcry_sexp_release (key);
473   *pkey = pub_key;
474   *skey = sec_key;
475 }
476
477
478 static void
479 get_dsa_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int transient_key)
480 {
481   gcry_sexp_t key_spec, key, pub_key, sec_key;
482   int rc;
483
484   rc = gcry_sexp_new (&key_spec,
485                       transient_key
486                       ? "(genkey (dsa (nbits 4:1024)(transient-key)))"
487                       : "(genkey (dsa (nbits 4:1024)))",
488                       0, 1);
489   if (rc)
490     die ("error creating S-expression: %s\n", gcry_strerror (rc));
491   rc = gcry_pk_genkey (&key, key_spec);
492   gcry_sexp_release (key_spec);
493   if (rc)
494     die ("error generating DSA key: %s\n", gcry_strerror (rc));
495
496   if (verbose > 1)
497     show_sexp ("generated DSA key:\n", key);
498
499   pub_key = gcry_sexp_find_token (key, "public-key", 0);
500   if (!pub_key)
501     die ("public part missing in key\n");
502
503   sec_key = gcry_sexp_find_token (key, "private-key", 0);
504   if (!sec_key)
505     die ("private part missing in key\n");
506
507   gcry_sexp_release (key);
508   *pkey = pub_key;
509   *skey = sec_key;
510 }
511
512
513 static void
514 get_dsa_key_fips186_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
515 {
516   gcry_sexp_t key_spec, key, pub_key, sec_key;
517   int rc;
518
519   rc = gcry_sexp_new
520     (&key_spec, "(genkey (dsa (nbits 4:2048)(use-fips186)))",  0, 1);
521   if (rc)
522     die ("error creating S-expression: %s\n", gcry_strerror (rc));
523   rc = gcry_pk_genkey (&key, key_spec);
524   gcry_sexp_release (key_spec);
525   if (rc)
526     die ("error generating DSA key: %s\n", gcry_strerror (rc));
527
528   if (verbose > 1)
529     show_sexp ("generated DSA key (fips 186):\n", key);
530
531   pub_key = gcry_sexp_find_token (key, "public-key", 0);
532   if (!pub_key)
533     die ("public part missing in key\n");
534
535   sec_key = gcry_sexp_find_token (key, "private-key", 0);
536   if (!sec_key)
537     die ("private part missing in key\n");
538
539   gcry_sexp_release (key);
540   *pkey = pub_key;
541   *skey = sec_key;
542 }
543
544
545 static void
546 get_dsa_key_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
547 {
548   gcry_sexp_t key_spec, key, pub_key, sec_key;
549   int rc;
550
551   rc = gcry_sexp_new
552     (&key_spec,
553      "(genkey (dsa (transient-key)(domain"
554      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
555      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
556      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
557      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
558      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
559      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
560      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
561      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
562      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
563      ")))", 0, 1);
564   if (rc)
565     die ("error creating S-expression: %s\n", gcry_strerror (rc));
566   rc = gcry_pk_genkey (&key, key_spec);
567   gcry_sexp_release (key_spec);
568   if (rc)
569     die ("error generating DSA key: %s\n", gcry_strerror (rc));
570
571   if (verbose > 1)
572     show_sexp ("generated DSA key:\n", key);
573
574   pub_key = gcry_sexp_find_token (key, "public-key", 0);
575   if (!pub_key)
576     die ("public part missing in key\n");
577
578   sec_key = gcry_sexp_find_token (key, "private-key", 0);
579   if (!sec_key)
580     die ("private part missing in key\n");
581
582   gcry_sexp_release (key);
583   *pkey = pub_key;
584   *skey = sec_key;
585 }
586
587 #if 0
588 static void
589 get_dsa_key_fips186_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
590 {
591   gcry_sexp_t key_spec, key, pub_key, sec_key;
592   int rc;
593
594   rc = gcry_sexp_new
595     (&key_spec,
596      "(genkey (dsa (transient-key)(use-fips186)(domain"
597      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
598      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
599      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
600      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
601      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
602      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
603      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
604      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
605      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
606      ")))", 0, 1);
607   if (rc)
608     die ("error creating S-expression: %s\n", gcry_strerror (rc));
609   rc = gcry_pk_genkey (&key, key_spec);
610   gcry_sexp_release (key_spec);
611   if (rc)
612     die ("error generating DSA key: %s\n", gcry_strerror (rc));
613
614   if (verbose > 1)
615     show_sexp ("generated DSA key:\n", key);
616
617   pub_key = gcry_sexp_find_token (key, "public-key", 0);
618   if (!pub_key)
619     die ("public part missing in key\n");
620
621   sec_key = gcry_sexp_find_token (key, "private-key", 0);
622   if (!sec_key)
623     die ("private part missing in key\n");
624
625   gcry_sexp_release (key);
626   *pkey = pub_key;
627   *skey = sec_key;
628 }
629 #endif /*0*/
630
631 static void
632 get_dsa_key_fips186_with_seed_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
633 {
634   gcry_sexp_t key_spec, key, pub_key, sec_key;
635   int rc;
636
637   rc = gcry_sexp_new
638     (&key_spec,
639      "(genkey"
640      "  (dsa"
641      "    (nbits 4:2048)"
642      "    (use-fips186)"
643      "    (transient-key)"
644      "    (derive-parms"
645      "      (seed #0cb1990c1fd3626055d7a0096f8fa99807399871#))))",
646      0, 1);
647   if (rc)
648     die ("error creating S-expression: %s\n", gcry_strerror (rc));
649   rc = gcry_pk_genkey (&key, key_spec);
650   gcry_sexp_release (key_spec);
651   if (rc)
652     die ("error generating DSA key: %s\n", gcry_strerror (rc));
653
654   if (verbose > 1)
655     show_sexp ("generated DSA key (fips 186 with seed):\n", key);
656
657   pub_key = gcry_sexp_find_token (key, "public-key", 0);
658   if (!pub_key)
659     die ("public part missing in key\n");
660
661   sec_key = gcry_sexp_find_token (key, "private-key", 0);
662   if (!sec_key)
663     die ("private part missing in key\n");
664
665   gcry_sexp_release (key);
666   *pkey = pub_key;
667   *skey = sec_key;
668 }
669
670
671 static void
672 check_run (void)
673 {
674   gpg_error_t err;
675   gcry_sexp_t pkey, skey;
676   int variant;
677
678   for (variant=0; variant < 3; variant++)
679     {
680       if (verbose)
681         fprintf (stderr, "Checking sample key (%d).\n", variant);
682       get_keys_sample (&pkey, &skey, variant);
683       /* Check gcry_pk_testkey which requires all elements.  */
684       err = gcry_pk_testkey (skey);
685       if ((variant == 0 && err)
686           || (variant > 0 && gpg_err_code (err) != GPG_ERR_NO_OBJ))
687           die ("gcry_pk_testkey failed: %s\n", gpg_strerror (err));
688       /* Run the usual check but expect an error from variant 2.  */
689       check_keys (pkey, skey, 800, variant == 2? GPG_ERR_NO_OBJ : 0);
690       gcry_sexp_release (pkey);
691       gcry_sexp_release (skey);
692     }
693
694   if (verbose)
695     fprintf (stderr, "Checking generated RSA key.\n");
696   get_keys_new (&pkey, &skey);
697   check_keys (pkey, skey, 800, 0);
698   gcry_sexp_release (pkey);
699   gcry_sexp_release (skey);
700
701   if (verbose)
702     fprintf (stderr, "Checking generated RSA key (X9.31).\n");
703   get_keys_x931_new (&pkey, &skey);
704   check_keys (pkey, skey, 800, 0);
705   gcry_sexp_release (pkey);
706   gcry_sexp_release (skey);
707
708   if (verbose)
709     fprintf (stderr, "Checking generated Elgamal key.\n");
710   get_elg_key_new (&pkey, &skey, 0);
711   check_keys (pkey, skey, 400, 0);
712   gcry_sexp_release (pkey);
713   gcry_sexp_release (skey);
714
715   if (verbose)
716     fprintf (stderr, "Checking passphrase generated Elgamal key.\n");
717   get_elg_key_new (&pkey, &skey, 1);
718   check_keys (pkey, skey, 800, 0);
719   gcry_sexp_release (pkey);
720   gcry_sexp_release (skey);
721
722   if (verbose)
723     fprintf (stderr, "Generating DSA key.\n");
724   get_dsa_key_new (&pkey, &skey, 0);
725   /* Fixme:  Add a check function for DSA keys.  */
726   gcry_sexp_release (pkey);
727   gcry_sexp_release (skey);
728
729   if (!gcry_fips_mode_active ())
730     {
731       if (verbose)
732         fprintf (stderr, "Generating transient DSA key.\n");
733       get_dsa_key_new (&pkey, &skey, 1);
734       /* Fixme:  Add a check function for DSA keys.  */
735       gcry_sexp_release (pkey);
736       gcry_sexp_release (skey);
737     }
738
739   if (verbose)
740     fprintf (stderr, "Generating DSA key (FIPS 186).\n");
741   get_dsa_key_fips186_new (&pkey, &skey);
742   /* Fixme:  Add a check function for DSA keys.  */
743   gcry_sexp_release (pkey);
744   gcry_sexp_release (skey);
745
746   if (verbose)
747     fprintf (stderr, "Generating DSA key with given domain.\n");
748   get_dsa_key_with_domain_new (&pkey, &skey);
749   /* Fixme:  Add a check function for DSA keys.  */
750   gcry_sexp_release (pkey);
751   gcry_sexp_release (skey);
752
753   /* We need new test vectors for get_dsa_key_fips186_with_domain_new.  */
754   if (verbose)
755     fprintf (stderr, "Generating DSA key with given domain (FIPS 186)"
756              " - skipped.\n");
757   /* get_dsa_key_fips186_with_domain_new (&pkey, &skey); */
758   /* /\* Fixme:  Add a check function for DSA keys.  *\/ */
759   /* gcry_sexp_release (pkey); */
760   /* gcry_sexp_release (skey); */
761
762   if (verbose)
763     fprintf (stderr, "Generating DSA key with given seed (FIPS 186).\n");
764   get_dsa_key_fips186_with_seed_new (&pkey, &skey);
765   /* Fixme:  Add a check function for DSA keys.  */
766   gcry_sexp_release (pkey);
767   gcry_sexp_release (skey);
768 }
769
770
771
772 static gcry_mpi_t
773 key_param_from_sexp (gcry_sexp_t sexp, const char *topname, const char *name)
774 {
775   gcry_sexp_t l1, l2;
776   gcry_mpi_t result;
777
778   l1 = gcry_sexp_find_token (sexp, topname, 0);
779   if (!l1)
780     return NULL;
781
782   l2 = gcry_sexp_find_token (l1, name, 0);
783   if (!l2)
784     {
785       gcry_sexp_release (l1);
786       return NULL;
787     }
788
789   result = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
790   gcry_sexp_release (l2);
791   gcry_sexp_release (l1);
792   return result;
793 }
794
795
796 static void
797 check_x931_derived_key (int what)
798 {
799   static struct {
800     const char *param;
801     const char *expected_d;
802   } testtable[] = {
803     { /* First example from X9.31 (D.1.1).  */
804       "(genkey\n"
805       "  (rsa\n"
806       "    (nbits 4:1024)\n"
807       "    (rsa-use-e 1:3)\n"
808       "    (derive-parms\n"
809       "      (Xp1 #1A1916DDB29B4EB7EB6732E128#)\n"
810       "      (Xp2 #192E8AAC41C576C822D93EA433#)\n"
811       "      (Xp  #D8CD81F035EC57EFE822955149D3BFF70C53520D\n"
812       "            769D6D76646C7A792E16EBD89FE6FC5B605A6493\n"
813       "            39DFC925A86A4C6D150B71B9EEA02D68885F5009\n"
814       "            B98BD984#)\n"
815       "      (Xq1 #1A5CF72EE770DE50CB09ACCEA9#)\n"
816       "      (Xq2 #134E4CAA16D2350A21D775C404#)\n"
817       "      (Xq  #CC1092495D867E64065DEE3E7955F2EBC7D47A2D\n"
818       "            7C9953388F97DDDC3E1CA19C35CA659EDC2FC325\n"
819       "            6D29C2627479C086A699A49C4C9CEE7EF7BD1B34\n"
820       "            321DE34A#))))\n",
821       "1CCDA20BCFFB8D517EE9666866621B11822C7950D55F4BB5BEE37989A7D173"
822       "12E326718BE0D79546EAAE87A56623B919B1715FFBD7F16028FC4007741961"
823       "C88C5D7B4DAAAC8D36A98C9EFBB26C8A4A0E6BC15B358E528A1AC9D0F042BE"
824       "B93BCA16B541B33F80C933A3B769285C462ED5677BFE89DF07BED5C127FD13"
825       "241D3C4B"
826     },
827
828     { /* Second example from X9.31 (D.2.1).  */
829       "(genkey\n"
830       "  (rsa\n"
831       "    (nbits 4:1536)\n"
832       "    (rsa-use-e 1:3)\n"
833       "    (derive-parms\n"
834       "      (Xp1 #18272558B61316348297EACA74#)\n"
835       "      (Xp2 #1E970E8C6C97CEF91F05B0FA80#)\n"
836       "      (Xp  #F7E943C7EF2169E930DCF23FE389EF7507EE8265\n"
837       "            0D42F4A0D3A3CEFABE367999BB30EE680B2FE064\n"
838       "            60F707F46005F8AA7CBFCDDC4814BBE7F0F8BC09\n"
839       "            318C8E51A48D134296E40D0BBDD282DCCBDDEE1D\n"
840       "            EC86F0B1C96EAFF5CDA70F9AEB6EE31E#)\n"
841       "      (Xq1 #11FDDA6E8128DC1629F75192BA#)\n"
842       "      (Xq2 #18AB178ECA907D72472F65E480#)\n"
843       "      (Xq  #C47560011412D6E13E3E7D007B5C05DBF5FF0D0F\n"
844       "            CFF1FA2070D16C7ABA93EDFB35D8700567E5913D\n"
845       "            B734E3FBD15862EBC59FA0425DFA131E549136E8\n"
846       "            E52397A8ABE4705EC4877D4F82C4AAC651B33DA6\n"
847       "            EA14B9D5F2A263DC65626E4D6CEAC767#))))\n",
848       "1FB56069985F18C4519694FB71055721A01F14422DC901C35B03A64D4A5BD1"
849       "259D573305F5B056AC931B82EDB084E39A0FD1D1A86CC5B147A264F7EF4EB2"
850       "0ED1E7FAAE5CAE4C30D5328B7F74C3CAA72C88B70DED8EDE207B8629DA2383"
851       "B78C3CE1CA3F9F218D78C938B35763AF2A8714664CC57F5CECE2413841F5E9"
852       "EDEC43B728E25A41BF3E1EF8D9EEE163286C9F8BF0F219D3B322C3E4B0389C"
853       "2E8BB28DC04C47DA2BF38823731266D2CF6CC3FC181738157624EF051874D0"
854       "BBCCB9F65C83"
855       /* Note that this example in X9.31 gives this value for D:
856
857         "7ED581A6617C6311465A53EDC4155C86807C5108B724070D6C0E9935296F44"
858         "96755CCC17D6C15AB24C6E0BB6C2138E683F4746A1B316C51E8993DFBD3AC8"
859         "3B479FEAB972B930C354CA2DFDD30F2A9CB222DC37B63B7881EE18A7688E0E"
860         "DE30F38728FE7C8635E324E2CD5D8EBCAA1C51993315FD73B38904E107D7A7"
861         "B7B10EDCA3896906FCF87BE367BB858CA1B27E2FC3C8674ECC8B0F92C0E270"
862         "BA2ECA3701311F68AFCE208DCC499B4B3DB30FF0605CE055D893BC1461D342"
863         "EF32E7D9720B"
864
865         This is a bug in X9.31, obviously introduced by using
866
867            d = e^{-1} mod (p-1)(q-1)
868
869          instead of using the universal exponent as required by 4.1.3:
870
871            d = e^{-1} mod lcm(p-1,q-1)
872
873          The examples in X9.31 seem to be pretty buggy, see
874          cipher/primegen.c for another bug.  Not only that I had to
875          spend 100 USD for the 66 pages of the document, it also took
876          me several hours to figure out that the bugs are in the
877          document and not in my code.
878        */
879     },
880
881     { /* First example from NIST RSAVS (B.1.1).  */
882       "(genkey\n"
883       "  (rsa\n"
884       "    (nbits 4:1024)\n"
885       "    (rsa-use-e 1:3)\n"
886       "    (derive-parms\n"
887       "      (Xp1 #1ed3d6368e101dab9124c92ac8#)\n"
888       "      (Xp2 #16e5457b8844967ce83cab8c11#)\n"
889       "      (Xp  #b79f2c2493b4b76f329903d7555b7f5f06aaa5ea\n"
890       "            ab262da1dcda8194720672a4e02229a0c71f60ae\n"
891       "            c4f0d2ed8d49ef583ca7d5eeea907c10801c302a\n"
892       "            cab44595#)\n"
893       "      (Xq1 #1a5d9e3fa34fb479bedea412f6#)\n"
894       "      (Xq2 #1f9cca85f185341516d92e82fd#)\n"
895       "      (Xq  #c8387fd38fa33ddcea6a9de1b2d55410663502db\n"
896       "            c225655a9310cceac9f4cf1bce653ec916d45788\n"
897       "            f8113c46bc0fa42bf5e8d0c41120c1612e2ea8bb\n"
898       "            2f389eda#))))\n",
899       "17ef7ad4fd96011b62d76dfb2261b4b3270ca8e07bc501be954f8719ef586b"
900       "f237e8f693dd16c23e7adecc40279dc6877c62ab541df5849883a5254fccfd"
901       "4072a657b7f4663953930346febd6bbd82f9a499038402cbf97fd5f068083a"
902       "c81ad0335c4aab0da19cfebe060a1bac7482738efafea078e21df785e56ea0"
903       "dc7e8feb"
904     },
905
906     { /* Second example from NIST RSAVS (B.1.1).  */
907       "(genkey\n"
908       "  (rsa\n"
909       "    (nbits 4:1536)\n"
910       "    (rsa-use-e 1:3)\n"
911       "    (derive-parms\n"
912       "      (Xp1 #1e64c1af460dff8842c22b64d0#)\n"
913       "      (Xp2 #1e948edcedba84039c81f2ac0c#)\n"
914       "      (Xp  #c8c67df894c882045ede26a9008ab09ea0672077\n"
915       "            d7bc71d412511cd93981ddde8f91b967da404056\n"
916       "            c39f105f7f239abdaff92923859920f6299e82b9\n"
917       "            5bd5b8c959948f4a034d81613d6235a3953b49ce\n"
918       "            26974eb7bb1f14843841281b363b9cdb#)\n"
919       "      (Xq1 #1f3df0f017ddd05611a97b6adb#)\n"
920       "      (Xq2 #143edd7b22d828913abf24ca4d#)\n"
921       "      (Xq  #f15147d0e7c04a1e3f37adde802cdc610999bf7a\n"
922       "            b0088434aaeda0c0ab3910b14d2ce56cb66bffd9\n"
923       "            7552195fae8b061077e03920814d8b9cfb5a3958\n"
924       "            b3a82c2a7fc97e55db543948d3396289245336ec\n"
925       "            9e3cb308cc655aebd766340da8921383#))))\n",
926       "1f8b19f3f5f2ac9fc599f110cad403dcd9bdf5f7f00fb2790e78e820398184"
927       "1f3fb3dd230fb223d898f45719d9b2d3525587ff2b8bcc7425e40550a5b536"
928       "1c8e9c1d26e83fbd9c33c64029c0e878b829d55def12912b73d94fd758c461"
929       "0f473e230c41b5e4c86e27c5a5029d82c811c88525d0269b95bd2ff272994a"
930       "dbd80f2c2ecf69065feb8abd8b445b9c6d306b1585d7d3d7576d49842bc7e2"
931       "8b4a2f88f4a47e71c3edd35fdf83f547ea5c2b532975c551ed5268f748b2c4"
932       "2ccf8a84835b"
933     }
934   };
935   gpg_error_t err;
936   gcry_sexp_t key_spec = NULL, key = NULL, pub_key = NULL, sec_key = NULL;
937   gcry_mpi_t d_expected = NULL, d_have = NULL;
938
939   if (what < 0 && what >= sizeof testtable)
940     die ("invalid WHAT value\n");
941
942   err = gcry_sexp_new (&key_spec, testtable[what].param, 0, 1);
943   if (err)
944     die ("error creating S-expression [%d]: %s\n", what, gpg_strerror (err));
945
946   {
947     unsigned nbits;
948     err = _gcry_pk_util_get_nbits(key_spec, &nbits);
949     if (err)
950       die ("nbits not found\n");
951     if (gcry_fips_mode_active() && nbits < 2048)
952       {
953         info("RSA key test with %d bits skipped in fips mode\n", nbits);
954         goto leave;
955       }
956   }
957
958   err = gcry_pk_genkey (&key, key_spec);
959   gcry_sexp_release (key_spec);
960   if (err)
961     {
962       fail ("error generating RSA key [%d]: %s\n", what, gpg_strerror (err));
963       goto leave;
964     }
965
966   pub_key = gcry_sexp_find_token (key, "public-key", 0);
967   if (!pub_key)
968     die ("public part missing in key [%d]\n", what);
969
970   sec_key = gcry_sexp_find_token (key, "private-key", 0);
971   if (!sec_key)
972     die ("private part missing in key [%d]\n", what);
973
974   err = gcry_mpi_scan
975     (&d_expected, GCRYMPI_FMT_HEX, testtable[what].expected_d, 0, NULL);
976   if (err)
977     die ("error converting string [%d]\n", what);
978
979   if (verbose > 1)
980     show_sexp ("generated key:\n", key);
981
982   d_have = key_param_from_sexp (sec_key, "rsa", "d");
983   if (!d_have)
984     die ("parameter d not found in RSA secret key [%d]\n", what);
985   if (gcry_mpi_cmp (d_expected, d_have))
986     {
987       show_sexp (NULL, sec_key);
988       die ("parameter d does match expected value [%d]\n", what);
989     }
990 leave:
991   gcry_mpi_release (d_expected);
992   gcry_mpi_release (d_have);
993
994   gcry_sexp_release (key);
995   gcry_sexp_release (pub_key);
996   gcry_sexp_release (sec_key);
997 }
998
999
1000
1001 static void
1002 check_ecc_sample_key (void)
1003 {
1004   static const char ecc_private_key[] =
1005     "(private-key\n"
1006     " (ecdsa\n"
1007     "  (curve \"NIST P-256\")\n"
1008     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
1009     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
1010     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
1011     "))";
1012   static const char ecc_private_key_wo_q[] =
1013     "(private-key\n"
1014     " (ecdsa\n"
1015     "  (curve \"NIST P-256\")\n"
1016     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
1017     "))";
1018   static const char ecc_public_key[] =
1019     "(public-key\n"
1020     " (ecdsa\n"
1021     "  (curve \"NIST P-256\")\n"
1022     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
1023     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)"
1024     "))";
1025   static const char hash_string[] =
1026     "(data (flags raw)\n"
1027     " (value #00112233445566778899AABBCCDDEEFF"
1028     /* */    "000102030405060708090A0B0C0D0E0F#))";
1029   static const char hash2_string[] =
1030     "(data (flags raw)\n"
1031     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
1032     /* */    "000102030405060708090A0B0C0D0E0F"
1033     /* */    "000102030405060708090A0B0C0D0E0F"
1034     /* */    "00112233445566778899AABBCCDDEEFF#))";
1035   /* hash2, but longer than curve length, so it will be truncated */
1036   static const char hash3_string[] =
1037     "(data (flags raw)\n"
1038     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
1039     /* */    "000102030405060708090A0B0C0D0E0F"
1040     /* */    "000102030405060708090A0B0C0D0E0F"
1041     /* */    "00112233445566778899AABBCCDDEEFF"
1042     /* */    "000102030405060708090A0B0C0D0E0F#))";
1043
1044   gpg_error_t err;
1045   gcry_sexp_t key, hash, hash2, hash3, sig, sig2;
1046
1047   if (verbose)
1048     fprintf (stderr, "Checking sample ECC key.\n");
1049
1050   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1051     die ("line %d: %s", __LINE__, gpg_strerror (err));
1052
1053   if ((err = gcry_sexp_new (&hash2, hash2_string, 0, 1)))
1054     die ("line %d: %s", __LINE__, gpg_strerror (err));
1055
1056   if ((err = gcry_sexp_new (&hash3, hash3_string, 0, 1)))
1057     die ("line %d: %s", __LINE__, gpg_strerror (err));
1058
1059   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1060     die ("line %d: %s", __LINE__, gpg_strerror (err));
1061
1062   if ((err = gcry_pk_sign (&sig, hash, key)))
1063     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1064
1065   gcry_sexp_release (key);
1066   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1067     die ("line %d: %s", __LINE__, gpg_strerror (err));
1068
1069   if ((err = gcry_pk_verify (sig, hash, key)))
1070     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1071
1072   /* Verify hash truncation */
1073   gcry_sexp_release (key);
1074   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1075     die ("line %d: %s", __LINE__, gpg_strerror (err));
1076
1077   if ((err = gcry_pk_sign (&sig2, hash2, key)))
1078     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1079
1080   gcry_sexp_release (sig);
1081   if ((err = gcry_pk_sign (&sig, hash3, key)))
1082     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1083
1084   gcry_sexp_release (key);
1085   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1086     die ("line %d: %s", __LINE__, gpg_strerror (err));
1087
1088   if ((err = gcry_pk_verify (sig, hash2, key)))
1089     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1090
1091   if ((err = gcry_pk_verify (sig2, hash3, key)))
1092     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1093
1094   /* Now try signing without the Q parameter.  */
1095
1096   gcry_sexp_release (key);
1097   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1098     die ("line %d: %s", __LINE__, gpg_strerror (err));
1099
1100   gcry_sexp_release (sig);
1101   if ((err = gcry_pk_sign (&sig, hash, key)))
1102     die ("gcry_pk_sign without Q failed: %s", gpg_strerror (err));
1103
1104   gcry_sexp_release (key);
1105   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1106     die ("line %d: %s", __LINE__, gpg_strerror (err));
1107
1108   if ((err = gcry_pk_verify (sig, hash, key)))
1109     die ("gcry_pk_verify signed without Q failed: %s", gpg_strerror (err));
1110
1111   gcry_sexp_release (sig);
1112   gcry_sexp_release (sig2);
1113   gcry_sexp_release (key);
1114   gcry_sexp_release (hash);
1115   gcry_sexp_release (hash2);
1116   gcry_sexp_release (hash3);
1117 }
1118
1119
1120 static void
1121 check_ed25519ecdsa_sample_key (void)
1122 {
1123   static const char ecc_private_key[] =
1124     "(private-key\n"
1125     " (ecc\n"
1126     "  (curve \"Ed25519\")\n"
1127     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1128     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1129     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1130     "))";
1131   static const char ecc_private_key_wo_q[] =
1132     "(private-key\n"
1133     " (ecc\n"
1134     "  (curve \"Ed25519\")\n"
1135     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1136     "))";
1137   static const char ecc_public_key[] =
1138     "(public-key\n"
1139     " (ecc\n"
1140     "  (curve \"Ed25519\")\n"
1141     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1142     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1143     "))";
1144   static const char ecc_public_key_comp[] =
1145     "(public-key\n"
1146     " (ecc\n"
1147     "  (curve \"Ed25519\")\n"
1148     "  (q #047b57c2c1d3ded93332b52d588dd45863478b658387413a718779c0dd1a6d95#)"
1149     "))";
1150   static const char hash_string[] =
1151     "(data (flags rfc6979)\n"
1152     " (hash sha256 #00112233445566778899AABBCCDDEEFF"
1153     /* */          "000102030405060708090A0B0C0D0E0F#))";
1154
1155   gpg_error_t err;
1156   gcry_sexp_t key, hash, sig;
1157
1158   if (verbose)
1159     fprintf (stderr, "Checking sample Ed25519/ECDSA key.\n");
1160
1161   /* Sign.  */
1162   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1163     die ("line %d: %s", __LINE__, gpg_strerror (err));
1164   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1165     die ("line %d: %s", __LINE__, gpg_strerror (err));
1166   if ((err = gcry_pk_sign (&sig, hash, key)))
1167     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1168
1169   /* Verify.  */
1170   gcry_sexp_release (key);
1171   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1172     die ("line %d: %s", __LINE__, gpg_strerror (err));
1173   if ((err = gcry_pk_verify (sig, hash, key)))
1174     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1175
1176   /* Verify again using a compressed public key.  */
1177   gcry_sexp_release (key);
1178   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1179     die ("line %d: %s", __LINE__, gpg_strerror (err));
1180   if ((err = gcry_pk_verify (sig, hash, key)))
1181     die ("gcry_pk_verify failed (comp): %s", gpg_strerror (err));
1182
1183   /* Sign without a Q parameter.  */
1184   gcry_sexp_release (key);
1185   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1186     die ("line %d: %s", __LINE__, gpg_strerror (err));
1187   gcry_sexp_release (sig);
1188   if ((err = gcry_pk_sign (&sig, hash, key)))
1189     die ("gcry_pk_sign w/o Q failed: %s", gpg_strerror (err));
1190
1191   /* Verify.  */
1192   gcry_sexp_release (key);
1193   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1194     die ("line %d: %s", __LINE__, gpg_strerror (err));
1195   if ((err = gcry_pk_verify (sig, hash, key)))
1196     die ("gcry_pk_verify signed w/o Q failed: %s", gpg_strerror (err));
1197
1198   /* Verify again using a compressed public key.  */
1199   gcry_sexp_release (key);
1200   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1201     die ("line %d: %s", __LINE__, gpg_strerror (err));
1202   if ((err = gcry_pk_verify (sig, hash, key)))
1203     die ("gcry_pk_verify signed w/o Q failed (comp): %s", gpg_strerror (err));
1204
1205   extract_cmp_data (sig, "r", ("a63123a783ef29b8276e08987daca4"
1206                                "655d0179e22199bf63691fd88eb64e15"));
1207   extract_cmp_data (sig, "s", ("0d9b45c696ab90b96b08812b485df185"
1208                                "623ddaf5d02fa65ca5056cb6bd0f16f1"));
1209
1210   gcry_sexp_release (sig);
1211   gcry_sexp_release (key);
1212   gcry_sexp_release (hash);
1213 }
1214
1215
1216 int
1217 main (int argc, char **argv)
1218 {
1219   int debug = 0;
1220   int i;
1221
1222   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1223     verbose = 1;
1224   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1225     {
1226       verbose = 2;
1227       debug = 1;
1228     }
1229
1230   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1231   if (!gcry_check_version (GCRYPT_VERSION))
1232     die ("version mismatch\n");
1233   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1234   if (debug)
1235     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
1236   /* No valuable keys are create, so we can speed up our RNG. */
1237   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1238
1239   for (i=0; i < 2; i++)
1240     check_run ();
1241
1242   for (i=0; i < 4; i++)
1243     check_x931_derived_key (i);
1244
1245   check_ecc_sample_key ();
1246   check_ed25519ecdsa_sample_key ();
1247
1248   return !!error_count;
1249 }