rsa: Use 2048 bit RSA keys for selftest.
[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:2048)))", 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:2048)(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:2048)(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 #if 0
561 static void
562 get_dsa_key_fips186_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
563 {
564   gcry_sexp_t key_spec, key, pub_key, sec_key;
565   int rc;
566
567   rc = gcry_sexp_new
568     (&key_spec,
569      "(genkey (dsa (transient-key)(use-fips186)(domain"
570      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
571      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
572      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
573      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
574      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
575      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
576      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
577      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
578      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
579      ")))", 0, 1);
580   if (rc)
581     die ("error creating S-expression: %s\n", gcry_strerror (rc));
582   rc = gcry_pk_genkey (&key, key_spec);
583   gcry_sexp_release (key_spec);
584   if (rc)
585     die ("error generating DSA key: %s\n", gcry_strerror (rc));
586
587   if (verbose > 1)
588     show_sexp ("generated DSA key:\n", key);
589
590   pub_key = gcry_sexp_find_token (key, "public-key", 0);
591   if (!pub_key)
592     die ("public part missing in key\n");
593
594   sec_key = gcry_sexp_find_token (key, "private-key", 0);
595   if (!sec_key)
596     die ("private part missing in key\n");
597
598   gcry_sexp_release (key);
599   *pkey = pub_key;
600   *skey = sec_key;
601 }
602 #endif /*0*/
603
604 static void
605 get_dsa_key_fips186_with_seed_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
606 {
607   gcry_sexp_t key_spec, key, pub_key, sec_key;
608   int rc;
609
610   rc = gcry_sexp_new
611     (&key_spec,
612      "(genkey"
613      "  (dsa"
614      "    (nbits 4:2048)"
615      "    (use-fips186)"
616      "    (transient-key)"
617      "    (derive-parms"
618      "      (seed #0cb1990c1fd3626055d7a0096f8fa99807399871#))))",
619      0, 1);
620   if (rc)
621     die ("error creating S-expression: %s\n", gcry_strerror (rc));
622   rc = gcry_pk_genkey (&key, key_spec);
623   gcry_sexp_release (key_spec);
624   if (rc)
625     die ("error generating DSA key: %s\n", gcry_strerror (rc));
626
627   if (verbose > 1)
628     show_sexp ("generated DSA key (fips 186 with seed):\n", key);
629
630   pub_key = gcry_sexp_find_token (key, "public-key", 0);
631   if (!pub_key)
632     die ("public part missing in key\n");
633
634   sec_key = gcry_sexp_find_token (key, "private-key", 0);
635   if (!sec_key)
636     die ("private part missing in key\n");
637
638   gcry_sexp_release (key);
639   *pkey = pub_key;
640   *skey = sec_key;
641 }
642
643
644 static void
645 check_run (void)
646 {
647   gpg_error_t err;
648   gcry_sexp_t pkey, skey;
649   int variant;
650
651   for (variant=0; variant < 3; variant++)
652     {
653       if (verbose)
654         fprintf (stderr, "Checking sample key (%d).\n", variant);
655       get_keys_sample (&pkey, &skey, variant);
656       /* Check gcry_pk_testkey which requires all elements.  */
657       err = gcry_pk_testkey (skey);
658       if ((variant == 0 && err)
659           || (variant > 0 && gpg_err_code (err) != GPG_ERR_NO_OBJ))
660           die ("gcry_pk_testkey failed: %s\n", gpg_strerror (err));
661       /* Run the usual check but expect an error from variant 2.  */
662       check_keys (pkey, skey, 800, variant == 2? GPG_ERR_NO_OBJ : 0);
663       gcry_sexp_release (pkey);
664       gcry_sexp_release (skey);
665     }
666
667   if (verbose)
668     fprintf (stderr, "Checking generated RSA key.\n");
669   get_keys_new (&pkey, &skey);
670   check_keys (pkey, skey, 800, 0);
671   gcry_sexp_release (pkey);
672   gcry_sexp_release (skey);
673
674   if (verbose)
675     fprintf (stderr, "Checking generated RSA key (X9.31).\n");
676   get_keys_x931_new (&pkey, &skey);
677   check_keys (pkey, skey, 800, 0);
678   gcry_sexp_release (pkey);
679   gcry_sexp_release (skey);
680
681   if (verbose)
682     fprintf (stderr, "Checking generated Elgamal key.\n");
683   get_elg_key_new (&pkey, &skey, 0);
684   check_keys (pkey, skey, 400, 0);
685   gcry_sexp_release (pkey);
686   gcry_sexp_release (skey);
687
688   if (verbose)
689     fprintf (stderr, "Checking passphrase generated Elgamal key.\n");
690   get_elg_key_new (&pkey, &skey, 1);
691   check_keys (pkey, skey, 800, 0);
692   gcry_sexp_release (pkey);
693   gcry_sexp_release (skey);
694
695   if (verbose)
696     fprintf (stderr, "Generating DSA key.\n");
697   get_dsa_key_new (&pkey, &skey, 0);
698   /* Fixme:  Add a check function for DSA keys.  */
699   gcry_sexp_release (pkey);
700   gcry_sexp_release (skey);
701
702   if (!gcry_fips_mode_active ())
703     {
704       if (verbose)
705         fprintf (stderr, "Generating transient DSA key.\n");
706       get_dsa_key_new (&pkey, &skey, 1);
707       /* Fixme:  Add a check function for DSA keys.  */
708       gcry_sexp_release (pkey);
709       gcry_sexp_release (skey);
710     }
711
712   if (verbose)
713     fprintf (stderr, "Generating DSA key (FIPS 186).\n");
714   get_dsa_key_fips186_new (&pkey, &skey);
715   /* Fixme:  Add a check function for DSA keys.  */
716   gcry_sexp_release (pkey);
717   gcry_sexp_release (skey);
718
719   if (verbose)
720     fprintf (stderr, "Generating DSA key with given domain.\n");
721   get_dsa_key_with_domain_new (&pkey, &skey);
722   /* Fixme:  Add a check function for DSA keys.  */
723   gcry_sexp_release (pkey);
724   gcry_sexp_release (skey);
725
726   /* We need new test vectors for get_dsa_key_fips186_with_domain_new.  */
727   if (verbose)
728     fprintf (stderr, "Generating DSA key with given domain (FIPS 186)"
729              " - skipped.\n");
730   /* get_dsa_key_fips186_with_domain_new (&pkey, &skey); */
731   /* /\* Fixme:  Add a check function for DSA keys.  *\/ */
732   /* gcry_sexp_release (pkey); */
733   /* gcry_sexp_release (skey); */
734
735   if (verbose)
736     fprintf (stderr, "Generating DSA key with given seed (FIPS 186).\n");
737   get_dsa_key_fips186_with_seed_new (&pkey, &skey);
738   /* Fixme:  Add a check function for DSA keys.  */
739   gcry_sexp_release (pkey);
740   gcry_sexp_release (skey);
741 }
742
743
744
745 static gcry_mpi_t
746 key_param_from_sexp (gcry_sexp_t sexp, const char *topname, const char *name)
747 {
748   gcry_sexp_t l1, l2;
749   gcry_mpi_t result;
750
751   l1 = gcry_sexp_find_token (sexp, topname, 0);
752   if (!l1)
753     return NULL;
754
755   l2 = gcry_sexp_find_token (l1, name, 0);
756   if (!l2)
757     {
758       gcry_sexp_release (l1);
759       return NULL;
760     }
761
762   result = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
763   gcry_sexp_release (l2);
764   gcry_sexp_release (l1);
765   return result;
766 }
767
768
769 static void
770 check_x931_derived_key (int what)
771 {
772   static struct {
773     const char *param;
774     const char *expected_d;
775   } testtable[] = {
776     { /* First example from X9.31 (D.1.1).  */
777       "(genkey\n"
778       "  (rsa\n"
779       "    (nbits 4:1024)\n"
780       "    (rsa-use-e 1:3)\n"
781       "    (derive-parms\n"
782       "      (Xp1 #1A1916DDB29B4EB7EB6732E128#)\n"
783       "      (Xp2 #192E8AAC41C576C822D93EA433#)\n"
784       "      (Xp  #D8CD81F035EC57EFE822955149D3BFF70C53520D\n"
785       "            769D6D76646C7A792E16EBD89FE6FC5B605A6493\n"
786       "            39DFC925A86A4C6D150B71B9EEA02D68885F5009\n"
787       "            B98BD984#)\n"
788       "      (Xq1 #1A5CF72EE770DE50CB09ACCEA9#)\n"
789       "      (Xq2 #134E4CAA16D2350A21D775C404#)\n"
790       "      (Xq  #CC1092495D867E64065DEE3E7955F2EBC7D47A2D\n"
791       "            7C9953388F97DDDC3E1CA19C35CA659EDC2FC325\n"
792       "            6D29C2627479C086A699A49C4C9CEE7EF7BD1B34\n"
793       "            321DE34A#))))\n",
794       "1CCDA20BCFFB8D517EE9666866621B11822C7950D55F4BB5BEE37989A7D173"
795       "12E326718BE0D79546EAAE87A56623B919B1715FFBD7F16028FC4007741961"
796       "C88C5D7B4DAAAC8D36A98C9EFBB26C8A4A0E6BC15B358E528A1AC9D0F042BE"
797       "B93BCA16B541B33F80C933A3B769285C462ED5677BFE89DF07BED5C127FD13"
798       "241D3C4B"
799     },
800
801     { /* Second example from X9.31 (D.2.1).  */
802       "(genkey\n"
803       "  (rsa\n"
804       "    (nbits 4:1536)\n"
805       "    (rsa-use-e 1:3)\n"
806       "    (derive-parms\n"
807       "      (Xp1 #18272558B61316348297EACA74#)\n"
808       "      (Xp2 #1E970E8C6C97CEF91F05B0FA80#)\n"
809       "      (Xp  #F7E943C7EF2169E930DCF23FE389EF7507EE8265\n"
810       "            0D42F4A0D3A3CEFABE367999BB30EE680B2FE064\n"
811       "            60F707F46005F8AA7CBFCDDC4814BBE7F0F8BC09\n"
812       "            318C8E51A48D134296E40D0BBDD282DCCBDDEE1D\n"
813       "            EC86F0B1C96EAFF5CDA70F9AEB6EE31E#)\n"
814       "      (Xq1 #11FDDA6E8128DC1629F75192BA#)\n"
815       "      (Xq2 #18AB178ECA907D72472F65E480#)\n"
816       "      (Xq  #C47560011412D6E13E3E7D007B5C05DBF5FF0D0F\n"
817       "            CFF1FA2070D16C7ABA93EDFB35D8700567E5913D\n"
818       "            B734E3FBD15862EBC59FA0425DFA131E549136E8\n"
819       "            E52397A8ABE4705EC4877D4F82C4AAC651B33DA6\n"
820       "            EA14B9D5F2A263DC65626E4D6CEAC767#))))\n",
821       "1FB56069985F18C4519694FB71055721A01F14422DC901C35B03A64D4A5BD1"
822       "259D573305F5B056AC931B82EDB084E39A0FD1D1A86CC5B147A264F7EF4EB2"
823       "0ED1E7FAAE5CAE4C30D5328B7F74C3CAA72C88B70DED8EDE207B8629DA2383"
824       "B78C3CE1CA3F9F218D78C938B35763AF2A8714664CC57F5CECE2413841F5E9"
825       "EDEC43B728E25A41BF3E1EF8D9EEE163286C9F8BF0F219D3B322C3E4B0389C"
826       "2E8BB28DC04C47DA2BF38823731266D2CF6CC3FC181738157624EF051874D0"
827       "BBCCB9F65C83"
828       /* Note that this example in X9.31 gives this value for D:
829
830         "7ED581A6617C6311465A53EDC4155C86807C5108B724070D6C0E9935296F44"
831         "96755CCC17D6C15AB24C6E0BB6C2138E683F4746A1B316C51E8993DFBD3AC8"
832         "3B479FEAB972B930C354CA2DFDD30F2A9CB222DC37B63B7881EE18A7688E0E"
833         "DE30F38728FE7C8635E324E2CD5D8EBCAA1C51993315FD73B38904E107D7A7"
834         "B7B10EDCA3896906FCF87BE367BB858CA1B27E2FC3C8674ECC8B0F92C0E270"
835         "BA2ECA3701311F68AFCE208DCC499B4B3DB30FF0605CE055D893BC1461D342"
836         "EF32E7D9720B"
837
838         This is a bug in X9.31, obviously introduced by using
839
840            d = e^{-1} mod (p-1)(q-1)
841
842          instead of using the universal exponent as required by 4.1.3:
843
844            d = e^{-1} mod lcm(p-1,q-1)
845
846          The examples in X9.31 seem to be pretty buggy, see
847          cipher/primegen.c for another bug.  Not only that I had to
848          spend 100 USD for the 66 pages of the document, it also took
849          me several hours to figure out that the bugs are in the
850          document and not in my code.
851        */
852     },
853
854     { /* First example from NIST RSAVS (B.1.1).  */
855       "(genkey\n"
856       "  (rsa\n"
857       "    (nbits 4:1024)\n"
858       "    (rsa-use-e 1:3)\n"
859       "    (derive-parms\n"
860       "      (Xp1 #1ed3d6368e101dab9124c92ac8#)\n"
861       "      (Xp2 #16e5457b8844967ce83cab8c11#)\n"
862       "      (Xp  #b79f2c2493b4b76f329903d7555b7f5f06aaa5ea\n"
863       "            ab262da1dcda8194720672a4e02229a0c71f60ae\n"
864       "            c4f0d2ed8d49ef583ca7d5eeea907c10801c302a\n"
865       "            cab44595#)\n"
866       "      (Xq1 #1a5d9e3fa34fb479bedea412f6#)\n"
867       "      (Xq2 #1f9cca85f185341516d92e82fd#)\n"
868       "      (Xq  #c8387fd38fa33ddcea6a9de1b2d55410663502db\n"
869       "            c225655a9310cceac9f4cf1bce653ec916d45788\n"
870       "            f8113c46bc0fa42bf5e8d0c41120c1612e2ea8bb\n"
871       "            2f389eda#))))\n",
872       "17ef7ad4fd96011b62d76dfb2261b4b3270ca8e07bc501be954f8719ef586b"
873       "f237e8f693dd16c23e7adecc40279dc6877c62ab541df5849883a5254fccfd"
874       "4072a657b7f4663953930346febd6bbd82f9a499038402cbf97fd5f068083a"
875       "c81ad0335c4aab0da19cfebe060a1bac7482738efafea078e21df785e56ea0"
876       "dc7e8feb"
877     },
878
879     { /* Second example from NIST RSAVS (B.1.1).  */
880       "(genkey\n"
881       "  (rsa\n"
882       "    (nbits 4:1536)\n"
883       "    (rsa-use-e 1:3)\n"
884       "    (derive-parms\n"
885       "      (Xp1 #1e64c1af460dff8842c22b64d0#)\n"
886       "      (Xp2 #1e948edcedba84039c81f2ac0c#)\n"
887       "      (Xp  #c8c67df894c882045ede26a9008ab09ea0672077\n"
888       "            d7bc71d412511cd93981ddde8f91b967da404056\n"
889       "            c39f105f7f239abdaff92923859920f6299e82b9\n"
890       "            5bd5b8c959948f4a034d81613d6235a3953b49ce\n"
891       "            26974eb7bb1f14843841281b363b9cdb#)\n"
892       "      (Xq1 #1f3df0f017ddd05611a97b6adb#)\n"
893       "      (Xq2 #143edd7b22d828913abf24ca4d#)\n"
894       "      (Xq  #f15147d0e7c04a1e3f37adde802cdc610999bf7a\n"
895       "            b0088434aaeda0c0ab3910b14d2ce56cb66bffd9\n"
896       "            7552195fae8b061077e03920814d8b9cfb5a3958\n"
897       "            b3a82c2a7fc97e55db543948d3396289245336ec\n"
898       "            9e3cb308cc655aebd766340da8921383#))))\n",
899       "1f8b19f3f5f2ac9fc599f110cad403dcd9bdf5f7f00fb2790e78e820398184"
900       "1f3fb3dd230fb223d898f45719d9b2d3525587ff2b8bcc7425e40550a5b536"
901       "1c8e9c1d26e83fbd9c33c64029c0e878b829d55def12912b73d94fd758c461"
902       "0f473e230c41b5e4c86e27c5a5029d82c811c88525d0269b95bd2ff272994a"
903       "dbd80f2c2ecf69065feb8abd8b445b9c6d306b1585d7d3d7576d49842bc7e2"
904       "8b4a2f88f4a47e71c3edd35fdf83f547ea5c2b532975c551ed5268f748b2c4"
905       "2ccf8a84835b"
906     }
907   };
908   gpg_error_t err;
909   gcry_sexp_t key_spec, key, pub_key, sec_key;
910   gcry_mpi_t d_expected, d_have;
911
912   if (what < 0 && what >= sizeof testtable)
913     die ("invalid WHAT value\n");
914
915   err = gcry_sexp_new (&key_spec, testtable[what].param, 0, 1);
916   if (err)
917     die ("error creating S-expression [%d]: %s\n", what, gpg_strerror (err));
918
919   err = gcry_pk_genkey (&key, key_spec);
920   gcry_sexp_release (key_spec);
921   if (err)
922     die ("error generating RSA key [%d]: %s\n", what, gpg_strerror (err));
923
924   pub_key = gcry_sexp_find_token (key, "public-key", 0);
925   if (!pub_key)
926     die ("public part missing in key [%d]\n", what);
927
928   sec_key = gcry_sexp_find_token (key, "private-key", 0);
929   if (!sec_key)
930     die ("private part missing in key [%d]\n", what);
931
932   err = gcry_mpi_scan
933     (&d_expected, GCRYMPI_FMT_HEX, testtable[what].expected_d, 0, NULL);
934   if (err)
935     die ("error converting string [%d]\n", what);
936
937   if (verbose > 1)
938     show_sexp ("generated key:\n", key);
939
940   d_have = key_param_from_sexp (sec_key, "rsa", "d");
941   if (!d_have)
942     die ("parameter d not found in RSA secret key [%d]\n", what);
943   if (gcry_mpi_cmp (d_expected, d_have))
944     {
945       show_sexp (NULL, sec_key);
946       die ("parameter d does match expected value [%d]\n", what);
947     }
948   gcry_mpi_release (d_expected);
949   gcry_mpi_release (d_have);
950
951   gcry_sexp_release (key);
952   gcry_sexp_release (pub_key);
953   gcry_sexp_release (sec_key);
954 }
955
956
957
958 static void
959 check_ecc_sample_key (void)
960 {
961   static const char ecc_private_key[] =
962     "(private-key\n"
963     " (ecdsa\n"
964     "  (curve \"NIST P-256\")\n"
965     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
966     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
967     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
968     "))";
969   static const char ecc_private_key_wo_q[] =
970     "(private-key\n"
971     " (ecdsa\n"
972     "  (curve \"NIST P-256\")\n"
973     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
974     "))";
975   static const char ecc_public_key[] =
976     "(public-key\n"
977     " (ecdsa\n"
978     "  (curve \"NIST P-256\")\n"
979     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
980     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)"
981     "))";
982   static const char hash_string[] =
983     "(data (flags raw)\n"
984     " (value #00112233445566778899AABBCCDDEEFF"
985     /* */    "000102030405060708090A0B0C0D0E0F#))";
986   static const char hash2_string[] =
987     "(data (flags raw)\n"
988     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
989     /* */    "000102030405060708090A0B0C0D0E0F"
990     /* */    "000102030405060708090A0B0C0D0E0F"
991     /* */    "00112233445566778899AABBCCDDEEFF#))";
992   /* hash2, but longer than curve length, so it will be truncated */
993   static const char hash3_string[] =
994     "(data (flags raw)\n"
995     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
996     /* */    "000102030405060708090A0B0C0D0E0F"
997     /* */    "000102030405060708090A0B0C0D0E0F"
998     /* */    "00112233445566778899AABBCCDDEEFF"
999     /* */    "000102030405060708090A0B0C0D0E0F#))";
1000
1001   gpg_error_t err;
1002   gcry_sexp_t key, hash, hash2, hash3, sig, sig2;
1003
1004   if (verbose)
1005     fprintf (stderr, "Checking sample ECC key.\n");
1006
1007   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1008     die ("line %d: %s", __LINE__, gpg_strerror (err));
1009
1010   if ((err = gcry_sexp_new (&hash2, hash2_string, 0, 1)))
1011     die ("line %d: %s", __LINE__, gpg_strerror (err));
1012
1013   if ((err = gcry_sexp_new (&hash3, hash3_string, 0, 1)))
1014     die ("line %d: %s", __LINE__, gpg_strerror (err));
1015
1016   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1017     die ("line %d: %s", __LINE__, gpg_strerror (err));
1018
1019   if ((err = gcry_pk_sign (&sig, hash, key)))
1020     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1021
1022   gcry_sexp_release (key);
1023   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1024     die ("line %d: %s", __LINE__, gpg_strerror (err));
1025
1026   if ((err = gcry_pk_verify (sig, hash, key)))
1027     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1028
1029   /* Verify hash truncation */
1030   gcry_sexp_release (key);
1031   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1032     die ("line %d: %s", __LINE__, gpg_strerror (err));
1033
1034   if ((err = gcry_pk_sign (&sig2, hash2, key)))
1035     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1036
1037   gcry_sexp_release (sig);
1038   if ((err = gcry_pk_sign (&sig, hash3, key)))
1039     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1040
1041   gcry_sexp_release (key);
1042   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1043     die ("line %d: %s", __LINE__, gpg_strerror (err));
1044
1045   if ((err = gcry_pk_verify (sig, hash2, key)))
1046     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1047
1048   if ((err = gcry_pk_verify (sig2, hash3, key)))
1049     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1050
1051   /* Now try signing without the Q parameter.  */
1052
1053   gcry_sexp_release (key);
1054   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1055     die ("line %d: %s", __LINE__, gpg_strerror (err));
1056
1057   gcry_sexp_release (sig);
1058   if ((err = gcry_pk_sign (&sig, hash, key)))
1059     die ("gcry_pk_sign without Q failed: %s", gpg_strerror (err));
1060
1061   gcry_sexp_release (key);
1062   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1063     die ("line %d: %s", __LINE__, gpg_strerror (err));
1064
1065   if ((err = gcry_pk_verify (sig, hash, key)))
1066     die ("gcry_pk_verify signed without Q failed: %s", gpg_strerror (err));
1067
1068   gcry_sexp_release (sig);
1069   gcry_sexp_release (sig2);
1070   gcry_sexp_release (key);
1071   gcry_sexp_release (hash);
1072   gcry_sexp_release (hash2);
1073   gcry_sexp_release (hash3);
1074 }
1075
1076
1077 static void
1078 check_ed25519ecdsa_sample_key (void)
1079 {
1080   static const char ecc_private_key[] =
1081     "(private-key\n"
1082     " (ecc\n"
1083     "  (curve \"Ed25519\")\n"
1084     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1085     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1086     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1087     "))";
1088   static const char ecc_private_key_wo_q[] =
1089     "(private-key\n"
1090     " (ecc\n"
1091     "  (curve \"Ed25519\")\n"
1092     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1093     "))";
1094   static const char ecc_public_key[] =
1095     "(public-key\n"
1096     " (ecc\n"
1097     "  (curve \"Ed25519\")\n"
1098     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1099     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1100     "))";
1101   static const char ecc_public_key_comp[] =
1102     "(public-key\n"
1103     " (ecc\n"
1104     "  (curve \"Ed25519\")\n"
1105     "  (q #047b57c2c1d3ded93332b52d588dd45863478b658387413a718779c0dd1a6d95#)"
1106     "))";
1107   static const char hash_string[] =
1108     "(data (flags rfc6979)\n"
1109     " (hash sha256 #00112233445566778899AABBCCDDEEFF"
1110     /* */          "000102030405060708090A0B0C0D0E0F#))";
1111
1112   gpg_error_t err;
1113   gcry_sexp_t key, hash, sig;
1114
1115   if (verbose)
1116     fprintf (stderr, "Checking sample Ed25519/ECDSA key.\n");
1117
1118   /* Sign.  */
1119   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1120     die ("line %d: %s", __LINE__, gpg_strerror (err));
1121   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1122     die ("line %d: %s", __LINE__, gpg_strerror (err));
1123   if ((err = gcry_pk_sign (&sig, hash, key)))
1124     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1125
1126   /* Verify.  */
1127   gcry_sexp_release (key);
1128   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1129     die ("line %d: %s", __LINE__, gpg_strerror (err));
1130   if ((err = gcry_pk_verify (sig, hash, key)))
1131     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1132
1133   /* Verify again using a compressed public key.  */
1134   gcry_sexp_release (key);
1135   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1136     die ("line %d: %s", __LINE__, gpg_strerror (err));
1137   if ((err = gcry_pk_verify (sig, hash, key)))
1138     die ("gcry_pk_verify failed (comp): %s", gpg_strerror (err));
1139
1140   /* Sign without a Q parameter.  */
1141   gcry_sexp_release (key);
1142   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1143     die ("line %d: %s", __LINE__, gpg_strerror (err));
1144   gcry_sexp_release (sig);
1145   if ((err = gcry_pk_sign (&sig, hash, key)))
1146     die ("gcry_pk_sign w/o Q failed: %s", gpg_strerror (err));
1147
1148   /* Verify.  */
1149   gcry_sexp_release (key);
1150   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1151     die ("line %d: %s", __LINE__, gpg_strerror (err));
1152   if ((err = gcry_pk_verify (sig, hash, key)))
1153     die ("gcry_pk_verify signed w/o Q failed: %s", gpg_strerror (err));
1154
1155   /* Verify again using a compressed public key.  */
1156   gcry_sexp_release (key);
1157   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1158     die ("line %d: %s", __LINE__, gpg_strerror (err));
1159   if ((err = gcry_pk_verify (sig, hash, key)))
1160     die ("gcry_pk_verify signed w/o Q failed (comp): %s", gpg_strerror (err));
1161
1162   extract_cmp_data (sig, "r", ("a63123a783ef29b8276e08987daca4"
1163                                "655d0179e22199bf63691fd88eb64e15"));
1164   extract_cmp_data (sig, "s", ("0d9b45c696ab90b96b08812b485df185"
1165                                "623ddaf5d02fa65ca5056cb6bd0f16f1"));
1166
1167   gcry_sexp_release (sig);
1168   gcry_sexp_release (key);
1169   gcry_sexp_release (hash);
1170 }
1171
1172
1173 int
1174 main (int argc, char **argv)
1175 {
1176   int debug = 0;
1177   int i;
1178
1179   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1180     verbose = 1;
1181   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1182     {
1183       verbose = 2;
1184       debug = 1;
1185     }
1186
1187   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1188   if (!gcry_check_version (GCRYPT_VERSION))
1189     die ("version mismatch\n");
1190   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1191   if (debug)
1192     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
1193   /* No valuable keys are create, so we can speed up our RNG. */
1194   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1195
1196   for (i=0; i < 2; i++)
1197     check_run ();
1198
1199   for (i=0; i < 4; i++)
1200     check_x931_derived_key (i);
1201
1202   check_ecc_sample_key ();
1203   check_ed25519ecdsa_sample_key ();
1204
1205   return !!error_count;
1206 }