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