Truncate hash values for ECDSA signature scheme
[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   static const char hash2_string[] =
984     "(data (flags raw)\n"
985     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
986     /* */    "000102030405060708090A0B0C0D0E0F"
987     /* */    "000102030405060708090A0B0C0D0E0F"
988     /* */    "00112233445566778899AABBCCDDEEFF#))";
989   /* hash2, but longer than curve length, so it will be truncated */
990   static const char hash3_string[] =
991     "(data (flags raw)\n"
992     " (hash sha1 #00112233445566778899AABBCCDDEEFF"
993     /* */    "000102030405060708090A0B0C0D0E0F"
994     /* */    "000102030405060708090A0B0C0D0E0F"
995     /* */    "00112233445566778899AABBCCDDEEFF"
996     /* */    "000102030405060708090A0B0C0D0E0F#))";
997
998   gpg_error_t err;
999   gcry_sexp_t key, hash, hash2, hash3, sig, sig2;
1000
1001   if (verbose)
1002     fprintf (stderr, "Checking sample ECC key.\n");
1003
1004   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1005     die ("line %d: %s", __LINE__, gpg_strerror (err));
1006
1007   if ((err = gcry_sexp_new (&hash2, hash2_string, 0, 1)))
1008     die ("line %d: %s", __LINE__, gpg_strerror (err));
1009
1010   if ((err = gcry_sexp_new (&hash3, hash3_string, 0, 1)))
1011     die ("line %d: %s", __LINE__, gpg_strerror (err));
1012
1013   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1014     die ("line %d: %s", __LINE__, gpg_strerror (err));
1015
1016   if ((err = gcry_pk_sign (&sig, hash, key)))
1017     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1018
1019   gcry_sexp_release (key);
1020   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1021     die ("line %d: %s", __LINE__, gpg_strerror (err));
1022
1023   if ((err = gcry_pk_verify (sig, hash, key)))
1024     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1025
1026   /* Verify hash truncation */
1027   gcry_sexp_release (key);
1028   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1029     die ("line %d: %s", __LINE__, gpg_strerror (err));
1030
1031   if ((err = gcry_pk_sign (&sig2, hash2, key)))
1032     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1033
1034   gcry_sexp_release (sig);
1035   if ((err = gcry_pk_sign (&sig, hash3, key)))
1036     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1037
1038   gcry_sexp_release (key);
1039   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1040     die ("line %d: %s", __LINE__, gpg_strerror (err));
1041
1042   if ((err = gcry_pk_verify (sig, hash2, key)))
1043     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1044
1045   if ((err = gcry_pk_verify (sig2, hash3, key)))
1046     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1047
1048   /* Now try signing without the Q parameter.  */
1049
1050   gcry_sexp_release (key);
1051   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1052     die ("line %d: %s", __LINE__, gpg_strerror (err));
1053
1054   gcry_sexp_release (sig);
1055   if ((err = gcry_pk_sign (&sig, hash, key)))
1056     die ("gcry_pk_sign without Q failed: %s", gpg_strerror (err));
1057
1058   gcry_sexp_release (key);
1059   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1060     die ("line %d: %s", __LINE__, gpg_strerror (err));
1061
1062   if ((err = gcry_pk_verify (sig, hash, key)))
1063     die ("gcry_pk_verify signed without Q failed: %s", gpg_strerror (err));
1064
1065   gcry_sexp_release (sig);
1066   gcry_sexp_release (sig2);
1067   gcry_sexp_release (key);
1068   gcry_sexp_release (hash);
1069   gcry_sexp_release (hash2);
1070   gcry_sexp_release (hash3);
1071 }
1072
1073
1074 static void
1075 check_ed25519ecdsa_sample_key (void)
1076 {
1077   static const char ecc_private_key[] =
1078     "(private-key\n"
1079     " (ecc\n"
1080     "  (curve \"Ed25519\")\n"
1081     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1082     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1083     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1084     "))";
1085   static const char ecc_private_key_wo_q[] =
1086     "(private-key\n"
1087     " (ecc\n"
1088     "  (curve \"Ed25519\")\n"
1089     "  (d #09A0C38E0F1699073541447C19DA12E3A07A7BFDB0C186E4AC5BCE6F23D55252#)"
1090     "))";
1091   static const char ecc_public_key[] =
1092     "(public-key\n"
1093     " (ecc\n"
1094     "  (curve \"Ed25519\")\n"
1095     "  (q #044C056555BE4084BB3D8D8895FDF7C2893DFE0256251923053010977D12658321"
1096     "        156D1ADDC07987713A418783658B476358D48D582DB53233D9DED3C1C2577B04#)"
1097     "))";
1098   static const char ecc_public_key_comp[] =
1099     "(public-key\n"
1100     " (ecc\n"
1101     "  (curve \"Ed25519\")\n"
1102     "  (q #047b57c2c1d3ded93332b52d588dd45863478b658387413a718779c0dd1a6d95#)"
1103     "))";
1104   static const char hash_string[] =
1105     "(data (flags rfc6979)\n"
1106     " (hash sha256 #00112233445566778899AABBCCDDEEFF"
1107     /* */          "000102030405060708090A0B0C0D0E0F#))";
1108
1109   gpg_error_t err;
1110   gcry_sexp_t key, hash, sig;
1111
1112   if (verbose)
1113     fprintf (stderr, "Checking sample Ed25519/ECDSA key.\n");
1114
1115   /* Sign.  */
1116   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
1117     die ("line %d: %s", __LINE__, gpg_strerror (err));
1118   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
1119     die ("line %d: %s", __LINE__, gpg_strerror (err));
1120   if ((err = gcry_pk_sign (&sig, hash, key)))
1121     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
1122
1123   /* Verify.  */
1124   gcry_sexp_release (key);
1125   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1126     die ("line %d: %s", __LINE__, gpg_strerror (err));
1127   if ((err = gcry_pk_verify (sig, hash, key)))
1128     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
1129
1130   /* Verify again using a compressed public key.  */
1131   gcry_sexp_release (key);
1132   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1133     die ("line %d: %s", __LINE__, gpg_strerror (err));
1134   if ((err = gcry_pk_verify (sig, hash, key)))
1135     die ("gcry_pk_verify failed (comp): %s", gpg_strerror (err));
1136
1137   /* Sign without a Q parameter.  */
1138   gcry_sexp_release (key);
1139   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
1140     die ("line %d: %s", __LINE__, gpg_strerror (err));
1141   gcry_sexp_release (sig);
1142   if ((err = gcry_pk_sign (&sig, hash, key)))
1143     die ("gcry_pk_sign w/o Q failed: %s", gpg_strerror (err));
1144
1145   /* Verify.  */
1146   gcry_sexp_release (key);
1147   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
1148     die ("line %d: %s", __LINE__, gpg_strerror (err));
1149   if ((err = gcry_pk_verify (sig, hash, key)))
1150     die ("gcry_pk_verify signed w/o Q failed: %s", gpg_strerror (err));
1151
1152   /* Verify again using a compressed public key.  */
1153   gcry_sexp_release (key);
1154   if ((err = gcry_sexp_new (&key, ecc_public_key_comp, 0, 1)))
1155     die ("line %d: %s", __LINE__, gpg_strerror (err));
1156   if ((err = gcry_pk_verify (sig, hash, key)))
1157     die ("gcry_pk_verify signed w/o Q failed (comp): %s", gpg_strerror (err));
1158
1159   extract_cmp_data (sig, "r", ("a63123a783ef29b8276e08987daca4"
1160                                "655d0179e22199bf63691fd88eb64e15"));
1161   extract_cmp_data (sig, "s", ("0d9b45c696ab90b96b08812b485df185"
1162                                "623ddaf5d02fa65ca5056cb6bd0f16f1"));
1163
1164   gcry_sexp_release (sig);
1165   gcry_sexp_release (key);
1166   gcry_sexp_release (hash);
1167 }
1168
1169
1170 int
1171 main (int argc, char **argv)
1172 {
1173   int debug = 0;
1174   int i;
1175
1176   if (argc > 1 && !strcmp (argv[1], "--verbose"))
1177     verbose = 1;
1178   else if (argc > 1 && !strcmp (argv[1], "--debug"))
1179     {
1180       verbose = 2;
1181       debug = 1;
1182     }
1183
1184   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1185   if (!gcry_check_version (GCRYPT_VERSION))
1186     die ("version mismatch\n");
1187   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1188   if (debug)
1189     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
1190   /* No valuable keys are create, so we can speed up our RNG. */
1191   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
1192
1193   for (i=0; i < 2; i++)
1194     check_run ();
1195
1196   for (i=0; i < 4; i++)
1197     check_x931_derived_key (i);
1198
1199   check_ecc_sample_key ();
1200   check_ed25519ecdsa_sample_key ();
1201
1202   return !!error_count;
1203 }