4534175075682534d94801a4f64084b2bcf0737c
[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.h"
30
31 /* Sample RSA keys, taken from basic.c.  */
32
33 static const char sample_private_key_1[] =
34 "(private-key\n"
35 " (openpgp-rsa\n"
36 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
37       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
38       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
39       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
40 "  (e #010001#)\n"
41 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
42       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
43       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
44       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
45 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
46       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
47 "  (q #00f7a7ca5367c661f8e62df34f0d05c10c88e5492348dd7bddc942c9a8f369f9"
48       "35a07785d2db805215ed786e4285df1658eed3ce84f469b81b50d358407b4ad361#)\n"
49 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
50       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
51 " )\n"
52 ")\n";
53
54 /* The same key as above but without p, q and u to test the non CRT case. */
55 static const char sample_private_key_1_1[] =
56 "(private-key\n"
57 " (openpgp-rsa\n"
58 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
59       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
60       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
61       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
62 "  (e #010001#)\n"
63 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
64       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
65       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
66       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
67 " )\n"
68 ")\n";
69
70 /* The same key as above but just without q to test the non CRT case.  This
71    should fail. */
72 static const char sample_private_key_1_2[] =
73 "(private-key\n"
74 " (openpgp-rsa\n"
75 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
76       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
77       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
78       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
79 "  (e #010001#)\n"
80 "  (d #046129F2489D71579BE0A75FE029BD6CDB574EBF57EA8A5B0FDA942CAB943B11"
81       "7D7BB95E5D28875E0F9FC5FCC06A72F6D502464DABDED78EF6B716177B83D5BD"
82       "C543DC5D3FED932E59F5897E92E6F58A0F33424106A3B6FA2CBF877510E4AC21"
83       "C3EE47851E97D12996222AC3566D4CCB0B83D164074ABF7DE655FC2446DA1781#)\n"
84 "  (p #00e861b700e17e8afe6837e7512e35b6ca11d0ae47d8b85161c67baf64377213"
85       "fe52d772f2035b3ca830af41d8a4120e1c1c70d12cc22f00d28d31dd48a8d424f1#)\n"
86 "  (u #304559a9ead56d2309d203811a641bb1a09626bc8eb36fffa23c968ec5bd891e"
87       "ebbafc73ae666e01ba7c8990bae06cc2bbe10b75e69fcacb353a6473079d8e9b#)\n"
88 " )\n"
89 ")\n";
90
91 static const char sample_public_key_1[] =
92 "(public-key\n"
93 " (rsa\n"
94 "  (n #00e0ce96f90b6c9e02f3922beada93fe50a875eac6bcc18bb9a9cf2e84965caa"
95       "2d1ff95a7f542465c6c0c19d276e4526ce048868a7a914fd343cc3a87dd74291"
96       "ffc565506d5bbb25cbac6a0e2dd1f8bcaab0d4a29c2f37c950f363484bf269f7"
97       "891440464baf79827e03a36e70b814938eebdc63e964247be75dc58b014b7ea251#)\n"
98 "  (e #010001#)\n"
99 " )\n"
100 ")\n";
101
102
103 static int verbose;
104
105 static void
106 die (const char *format, ...)
107 {
108   va_list arg_ptr ;
109
110   va_start( arg_ptr, format ) ;
111   vfprintf (stderr, format, arg_ptr );
112   va_end(arg_ptr);
113   if (*format && format[strlen(format)-1] != '\n')
114     putc ('\n', stderr);
115   exit (1);
116 }
117
118 static void
119 show_sexp (const char *prefix, gcry_sexp_t a)
120 {
121   char *buf;
122   size_t size;
123
124   if (prefix)
125     fputs (prefix, stderr);
126   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
127   buf = gcry_xmalloc (size);
128
129   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
130   fprintf (stderr, "%.*s", (int)size, buf);
131   gcry_free (buf);
132 }
133
134
135 static void
136 check_keys_crypt (gcry_sexp_t pkey, gcry_sexp_t skey,
137                   gcry_sexp_t plain0, gpg_err_code_t decrypt_fail_code)
138 {
139   gcry_sexp_t plain1, cipher, l;
140   gcry_mpi_t x0, x1;
141   int rc;
142   int have_flags;
143
144   /* Extract data from plaintext.  */
145   l = gcry_sexp_find_token (plain0, "value", 0);
146   x0 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
147
148   /* Encrypt data.  */
149   rc = gcry_pk_encrypt (&cipher, plain0, pkey);
150   if (rc)
151     die ("encryption failed: %s\n", gcry_strerror (rc));
152
153   l = gcry_sexp_find_token (cipher, "flags", 0);
154   have_flags = !!l;
155   gcry_sexp_release (l);
156
157   /* Decrypt data.  */
158   rc = gcry_pk_decrypt (&plain1, cipher, skey);
159   gcry_sexp_release (cipher);
160   if (rc)
161     {
162       if (decrypt_fail_code && gpg_err_code (rc) == decrypt_fail_code)
163         return; /* This is the expected failure code.  */
164       die ("decryption failed: %s\n", gcry_strerror (rc));
165     }
166
167   /* Extract decrypted data.  Note that for compatibility reasons, the
168      output of gcry_pk_decrypt depends on whether a flags lists (even
169      if empty) occurs in its input data.  Because we passed the output
170      of encrypt directly to decrypt, such a flag value won't be there
171      as of today.  We check it anyway. */
172   l = gcry_sexp_find_token (plain1, "value", 0);
173   if (l)
174     {
175       if (!have_flags)
176         die ("compatibility mode of pk_decrypt broken\n");
177       gcry_sexp_release (plain1);
178       x1 = gcry_sexp_nth_mpi (l, 1, GCRYMPI_FMT_USG);
179       gcry_sexp_release (l);
180     }
181   else
182     {
183       if (have_flags)
184         die ("compatibility mode of pk_decrypt broken\n");
185       x1 = gcry_sexp_nth_mpi (plain1, 0, GCRYMPI_FMT_USG);
186       gcry_sexp_release (plain1);
187     }
188
189   /* Compare.  */
190   if (gcry_mpi_cmp (x0, x1))
191     die ("data corrupted\n");
192 }
193
194 static void
195 check_keys (gcry_sexp_t pkey, gcry_sexp_t skey, unsigned int nbits_data,
196             gpg_err_code_t decrypt_fail_code)
197 {
198   gcry_sexp_t plain;
199   gcry_mpi_t x;
200   int rc;
201
202   /* Create plain text.  */
203   x = gcry_mpi_new (nbits_data);
204   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
205
206   rc = gcry_sexp_build (&plain, NULL, "(data (flags raw) (value %m))", x);
207   if (rc)
208     die ("converting data for encryption failed: %s\n",
209          gcry_strerror (rc));
210
211   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
212   gcry_sexp_release (plain);
213   gcry_mpi_release (x);
214
215   /* Create plain text.  */
216   x = gcry_mpi_new (nbits_data);
217   gcry_mpi_randomize (x, nbits_data, GCRY_WEAK_RANDOM);
218
219   rc = gcry_sexp_build (&plain, NULL,
220                         "(data (flags raw no-blinding) (value %m))", x);
221   if (rc)
222     die ("converting data for encryption failed: %s\n",
223          gcry_strerror (rc));
224
225   check_keys_crypt (pkey, skey, plain, decrypt_fail_code);
226   gcry_sexp_release (plain);
227 }
228
229 static void
230 get_keys_sample (gcry_sexp_t *pkey, gcry_sexp_t *skey, int secret_variant)
231 {
232   gcry_sexp_t pub_key, sec_key;
233   int rc;
234   static const char *secret;
235
236
237   switch (secret_variant)
238     {
239     case 0: secret = sample_private_key_1; break;
240     case 1: secret = sample_private_key_1_1; break;
241     case 2: secret = sample_private_key_1_2; break;
242     default: die ("BUG\n");
243     }
244
245   rc = gcry_sexp_sscan (&pub_key, NULL, sample_public_key_1,
246                         strlen (sample_public_key_1));
247   if (!rc)
248     rc = gcry_sexp_sscan (&sec_key, NULL, secret, strlen (secret));
249   if (rc)
250     die ("converting sample keys failed: %s\n", gcry_strerror (rc));
251
252   *pkey = pub_key;
253   *skey = sec_key;
254 }
255
256 static void
257 get_keys_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
258 {
259   gcry_sexp_t key_spec, key, pub_key, sec_key;
260   int rc;
261
262   rc = gcry_sexp_new (&key_spec,
263                       "(genkey (rsa (nbits 4:1024)))", 0, 1);
264   if (rc)
265     die ("error creating S-expression: %s\n", gcry_strerror (rc));
266   rc = gcry_pk_genkey (&key, key_spec);
267   gcry_sexp_release (key_spec);
268   if (rc)
269     die ("error generating RSA key: %s\n", gcry_strerror (rc));
270
271   if (verbose > 1)
272     show_sexp ("generated RSA key:\n", key);
273
274   pub_key = gcry_sexp_find_token (key, "public-key", 0);
275   if (! pub_key)
276     die ("public part missing in key\n");
277
278   sec_key = gcry_sexp_find_token (key, "private-key", 0);
279   if (! sec_key)
280     die ("private part missing in key\n");
281
282   gcry_sexp_release (key);
283   *pkey = pub_key;
284   *skey = sec_key;
285 }
286
287
288 static void
289 get_keys_x931_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
290 {
291   gcry_sexp_t key_spec, key, pub_key, sec_key;
292   int rc;
293
294   rc = gcry_sexp_new (&key_spec,
295                       "(genkey (rsa (nbits 4:1024)(use-x931)))", 0, 1);
296   if (rc)
297     die ("error creating S-expression: %s\n", gcry_strerror (rc));
298   rc = gcry_pk_genkey (&key, key_spec);
299   gcry_sexp_release (key_spec);
300   if (rc)
301     die ("error generating RSA key: %s\n", gcry_strerror (rc));
302
303   if (verbose > 1)
304     show_sexp ("generated RSA (X9.31) key:\n", key);
305
306   pub_key = gcry_sexp_find_token (key, "public-key", 0);
307   if (!pub_key)
308     die ("public part missing in key\n");
309
310   sec_key = gcry_sexp_find_token (key, "private-key", 0);
311   if (!sec_key)
312     die ("private part missing in key\n");
313
314   gcry_sexp_release (key);
315   *pkey = pub_key;
316   *skey = sec_key;
317 }
318
319
320 static void
321 get_elg_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int fixed_x)
322 {
323   gcry_sexp_t key_spec, key, pub_key, sec_key;
324   int rc;
325
326   rc = gcry_sexp_new
327     (&key_spec,
328      (fixed_x
329       ? "(genkey (elg (nbits 4:1024)(xvalue my.not-so-secret.key)))"
330       : "(genkey (elg (nbits 3:512)))"),
331      0, 1);
332
333   if (rc)
334     die ("error creating S-expression: %s\n", gcry_strerror (rc));
335   rc = gcry_pk_genkey (&key, key_spec);
336   gcry_sexp_release (key_spec);
337   if (rc)
338     die ("error generating Elgamal key: %s\n", gcry_strerror (rc));
339
340   if (verbose > 1)
341     show_sexp ("generated ELG key:\n", key);
342
343   pub_key = gcry_sexp_find_token (key, "public-key", 0);
344   if (!pub_key)
345     die ("public part missing in key\n");
346
347   sec_key = gcry_sexp_find_token (key, "private-key", 0);
348   if (!sec_key)
349     die ("private part missing in key\n");
350
351   gcry_sexp_release (key);
352   *pkey = pub_key;
353   *skey = sec_key;
354 }
355
356
357 static void
358 get_dsa_key_new (gcry_sexp_t *pkey, gcry_sexp_t *skey, int transient_key)
359 {
360   gcry_sexp_t key_spec, key, pub_key, sec_key;
361   int rc;
362
363   rc = gcry_sexp_new (&key_spec,
364                       transient_key
365                       ? "(genkey (dsa (nbits 4:1024)(transient-key)))"
366                       : "(genkey (dsa (nbits 4:1024)))",
367                       0, 1);
368   if (rc)
369     die ("error creating S-expression: %s\n", gcry_strerror (rc));
370   rc = gcry_pk_genkey (&key, key_spec);
371   gcry_sexp_release (key_spec);
372   if (rc)
373     die ("error generating DSA key: %s\n", gcry_strerror (rc));
374
375   if (verbose > 1)
376     show_sexp ("generated DSA key:\n", key);
377
378   pub_key = gcry_sexp_find_token (key, "public-key", 0);
379   if (!pub_key)
380     die ("public part missing in key\n");
381
382   sec_key = gcry_sexp_find_token (key, "private-key", 0);
383   if (!sec_key)
384     die ("private part missing in key\n");
385
386   gcry_sexp_release (key);
387   *pkey = pub_key;
388   *skey = sec_key;
389 }
390
391
392 static void
393 get_dsa_key_fips186_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
394 {
395   gcry_sexp_t key_spec, key, pub_key, sec_key;
396   int rc;
397
398   rc = gcry_sexp_new
399     (&key_spec, "(genkey (dsa (nbits 4:1024)(use-fips186)))",  0, 1);
400   if (rc)
401     die ("error creating S-expression: %s\n", gcry_strerror (rc));
402   rc = gcry_pk_genkey (&key, key_spec);
403   gcry_sexp_release (key_spec);
404   if (rc)
405     die ("error generating DSA key: %s\n", gcry_strerror (rc));
406
407   if (verbose > 1)
408     show_sexp ("generated DSA key (fips 186):\n", key);
409
410   pub_key = gcry_sexp_find_token (key, "public-key", 0);
411   if (!pub_key)
412     die ("public part missing in key\n");
413
414   sec_key = gcry_sexp_find_token (key, "private-key", 0);
415   if (!sec_key)
416     die ("private part missing in key\n");
417
418   gcry_sexp_release (key);
419   *pkey = pub_key;
420   *skey = sec_key;
421 }
422
423
424 static void
425 get_dsa_key_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
426 {
427   gcry_sexp_t key_spec, key, pub_key, sec_key;
428   int rc;
429
430   rc = gcry_sexp_new
431     (&key_spec,
432      "(genkey (dsa (transient-key)(domain"
433      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
434      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
435      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
436      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
437      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
438      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
439      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
440      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
441      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
442      ")))", 0, 1);
443   if (rc)
444     die ("error creating S-expression: %s\n", gcry_strerror (rc));
445   rc = gcry_pk_genkey (&key, key_spec);
446   gcry_sexp_release (key_spec);
447   if (rc)
448     die ("error generating DSA key: %s\n", gcry_strerror (rc));
449
450   if (verbose > 1)
451     show_sexp ("generated DSA key:\n", key);
452
453   pub_key = gcry_sexp_find_token (key, "public-key", 0);
454   if (!pub_key)
455     die ("public part missing in key\n");
456
457   sec_key = gcry_sexp_find_token (key, "private-key", 0);
458   if (!sec_key)
459     die ("private part missing in key\n");
460
461   gcry_sexp_release (key);
462   *pkey = pub_key;
463   *skey = sec_key;
464 }
465
466 static void
467 get_dsa_key_fips186_with_domain_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
468 {
469   gcry_sexp_t key_spec, key, pub_key, sec_key;
470   int rc;
471
472   rc = gcry_sexp_new
473     (&key_spec,
474      "(genkey (dsa (transient-key)(use-fips186)(domain"
475      "(p #d3aed1876054db831d0c1348fbb1ada72507e5fbf9a62cbd47a63aeb7859d6921"
476      "4adeb9146a6ec3f43520f0fd8e3125dd8bbc5d87405d1ac5f82073cd762a3f8d7"
477      "74322657c9da88a7d2f0e1a9ceb84a39cb40876179e6a76e400498de4bb9379b0"
478      "5f5feb7b91eb8fea97ee17a955a0a8a37587a272c4719d6feb6b54ba4ab69#)"
479      "(q #9c916d121de9a03f71fb21bc2e1c0d116f065a4f#)"
480      "(g #8157c5f68ca40b3ded11c353327ab9b8af3e186dd2e8dade98761a0996dda99ab"
481      "0250d3409063ad99efae48b10c6ab2bba3ea9a67b12b911a372a2bba260176fad"
482      "b4b93247d9712aad13aa70216c55da9858f7a298deb670a403eb1e7c91b847f1e"
483      "ccfbd14bd806fd42cf45dbb69cd6d6b43add2a78f7d16928eaa04458dea44#)"
484      ")))", 0, 1);
485   if (rc)
486     die ("error creating S-expression: %s\n", gcry_strerror (rc));
487   rc = gcry_pk_genkey (&key, key_spec);
488   gcry_sexp_release (key_spec);
489   if (rc)
490     die ("error generating DSA key: %s\n", gcry_strerror (rc));
491
492   if (verbose > 1)
493     show_sexp ("generated DSA key:\n", key);
494
495   pub_key = gcry_sexp_find_token (key, "public-key", 0);
496   if (!pub_key)
497     die ("public part missing in key\n");
498
499   sec_key = gcry_sexp_find_token (key, "private-key", 0);
500   if (!sec_key)
501     die ("private part missing in key\n");
502
503   gcry_sexp_release (key);
504   *pkey = pub_key;
505   *skey = sec_key;
506 }
507
508
509 static void
510 get_dsa_key_fips186_with_seed_new (gcry_sexp_t *pkey, gcry_sexp_t *skey)
511 {
512   gcry_sexp_t key_spec, key, pub_key, sec_key;
513   int rc;
514
515   rc = gcry_sexp_new
516     (&key_spec,
517      "(genkey"
518      "  (dsa"
519      "    (nbits 4:1024)"
520      "    (use-fips186)"
521      "    (transient-key)"
522      "    (derive-parms"
523      "      (seed #0cb1990c1fd3626055d7a0096f8fa99807399871#))))",
524      0, 1);
525   if (rc)
526     die ("error creating S-expression: %s\n", gcry_strerror (rc));
527   rc = gcry_pk_genkey (&key, key_spec);
528   gcry_sexp_release (key_spec);
529   if (rc)
530     die ("error generating DSA key: %s\n", gcry_strerror (rc));
531
532   if (verbose > 1)
533     show_sexp ("generated DSA key (fips 186 with seed):\n", key);
534
535   pub_key = gcry_sexp_find_token (key, "public-key", 0);
536   if (!pub_key)
537     die ("public part missing in key\n");
538
539   sec_key = gcry_sexp_find_token (key, "private-key", 0);
540   if (!sec_key)
541     die ("private part missing in key\n");
542
543   gcry_sexp_release (key);
544   *pkey = pub_key;
545   *skey = sec_key;
546 }
547
548
549 static void
550 check_run (void)
551 {
552   gpg_error_t err;
553   gcry_sexp_t pkey, skey;
554   int variant;
555
556   for (variant=0; variant < 3; variant++)
557     {
558       if (verbose)
559         fprintf (stderr, "Checking sample key (%d).\n", variant);
560       get_keys_sample (&pkey, &skey, variant);
561       /* Check gcry_pk_testkey which requires all elements.  */
562       err = gcry_pk_testkey (skey);
563       if ((variant == 0 && err)
564           || (variant > 0 && gpg_err_code (err) != GPG_ERR_NO_OBJ))
565           die ("gcry_pk_testkey failed: %s\n", gpg_strerror (err));
566       /* Run the usual check but expect an error from variant 2.  */
567       check_keys (pkey, skey, 800, variant == 2? GPG_ERR_NO_OBJ : 0);
568       gcry_sexp_release (pkey);
569       gcry_sexp_release (skey);
570     }
571
572   if (verbose)
573     fprintf (stderr, "Checking generated RSA key.\n");
574   get_keys_new (&pkey, &skey);
575   check_keys (pkey, skey, 800, 0);
576   gcry_sexp_release (pkey);
577   gcry_sexp_release (skey);
578
579   if (verbose)
580     fprintf (stderr, "Checking generated RSA key (X9.31).\n");
581   get_keys_x931_new (&pkey, &skey);
582   check_keys (pkey, skey, 800, 0);
583   gcry_sexp_release (pkey);
584   gcry_sexp_release (skey);
585
586   if (verbose)
587     fprintf (stderr, "Checking generated Elgamal key.\n");
588   get_elg_key_new (&pkey, &skey, 0);
589   check_keys (pkey, skey, 400, 0);
590   gcry_sexp_release (pkey);
591   gcry_sexp_release (skey);
592
593   if (verbose)
594     fprintf (stderr, "Checking passphrase generated Elgamal key.\n");
595   get_elg_key_new (&pkey, &skey, 1);
596   check_keys (pkey, skey, 800, 0);
597   gcry_sexp_release (pkey);
598   gcry_sexp_release (skey);
599
600   if (verbose)
601     fprintf (stderr, "Generating DSA key.\n");
602   get_dsa_key_new (&pkey, &skey, 0);
603   /* Fixme:  Add a check function for DSA keys.  */
604   gcry_sexp_release (pkey);
605   gcry_sexp_release (skey);
606
607   if (!gcry_fips_mode_active ())
608     {
609       if (verbose)
610         fprintf (stderr, "Generating transient DSA key.\n");
611       get_dsa_key_new (&pkey, &skey, 1);
612       /* Fixme:  Add a check function for DSA keys.  */
613       gcry_sexp_release (pkey);
614       gcry_sexp_release (skey);
615     }
616
617   if (verbose)
618     fprintf (stderr, "Generating DSA key (FIPS 186).\n");
619   get_dsa_key_fips186_new (&pkey, &skey);
620   /* Fixme:  Add a check function for DSA keys.  */
621   gcry_sexp_release (pkey);
622   gcry_sexp_release (skey);
623
624   if (verbose)
625     fprintf (stderr, "Generating DSA key with given domain.\n");
626   get_dsa_key_with_domain_new (&pkey, &skey);
627   /* Fixme:  Add a check function for DSA keys.  */
628   gcry_sexp_release (pkey);
629   gcry_sexp_release (skey);
630
631   if (verbose)
632     fprintf (stderr, "Generating DSA key with given domain (FIPS 186).\n");
633   get_dsa_key_fips186_with_domain_new (&pkey, &skey);
634   /* Fixme:  Add a check function for DSA keys.  */
635   gcry_sexp_release (pkey);
636   gcry_sexp_release (skey);
637
638   if (verbose)
639     fprintf (stderr, "Generating DSA key with given seed (FIPS 186).\n");
640   get_dsa_key_fips186_with_seed_new (&pkey, &skey);
641   /* Fixme:  Add a check function for DSA keys.  */
642   gcry_sexp_release (pkey);
643   gcry_sexp_release (skey);
644 }
645
646
647
648 static gcry_mpi_t
649 key_param_from_sexp (gcry_sexp_t sexp, const char *topname, const char *name)
650 {
651   gcry_sexp_t l1, l2;
652   gcry_mpi_t result;
653
654   l1 = gcry_sexp_find_token (sexp, topname, 0);
655   if (!l1)
656     return NULL;
657
658   l2 = gcry_sexp_find_token (l1, name, 0);
659   if (!l2)
660     {
661       gcry_sexp_release (l1);
662       return NULL;
663     }
664
665   result = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
666   gcry_sexp_release (l2);
667   gcry_sexp_release (l1);
668   return result;
669 }
670
671
672 static void
673 check_x931_derived_key (int what)
674 {
675   static struct {
676     const char *param;
677     const char *expected_d;
678   } testtable[] = {
679     { /* First example from X9.31 (D.1.1).  */
680       "(genkey\n"
681       "  (rsa\n"
682       "    (nbits 4:1024)\n"
683       "    (rsa-use-e 1:3)\n"
684       "    (derive-parms\n"
685       "      (Xp1 #1A1916DDB29B4EB7EB6732E128#)\n"
686       "      (Xp2 #192E8AAC41C576C822D93EA433#)\n"
687       "      (Xp  #D8CD81F035EC57EFE822955149D3BFF70C53520D\n"
688       "            769D6D76646C7A792E16EBD89FE6FC5B605A6493\n"
689       "            39DFC925A86A4C6D150B71B9EEA02D68885F5009\n"
690       "            B98BD984#)\n"
691       "      (Xq1 #1A5CF72EE770DE50CB09ACCEA9#)\n"
692       "      (Xq2 #134E4CAA16D2350A21D775C404#)\n"
693       "      (Xq  #CC1092495D867E64065DEE3E7955F2EBC7D47A2D\n"
694       "            7C9953388F97DDDC3E1CA19C35CA659EDC2FC325\n"
695       "            6D29C2627479C086A699A49C4C9CEE7EF7BD1B34\n"
696       "            321DE34A#))))\n",
697       "1CCDA20BCFFB8D517EE9666866621B11822C7950D55F4BB5BEE37989A7D173"
698       "12E326718BE0D79546EAAE87A56623B919B1715FFBD7F16028FC4007741961"
699       "C88C5D7B4DAAAC8D36A98C9EFBB26C8A4A0E6BC15B358E528A1AC9D0F042BE"
700       "B93BCA16B541B33F80C933A3B769285C462ED5677BFE89DF07BED5C127FD13"
701       "241D3C4B"
702     },
703
704     { /* Second example from X9.31 (D.2.1).  */
705       "(genkey\n"
706       "  (rsa\n"
707       "    (nbits 4:1536)\n"
708       "    (rsa-use-e 1:3)\n"
709       "    (derive-parms\n"
710       "      (Xp1 #18272558B61316348297EACA74#)\n"
711       "      (Xp2 #1E970E8C6C97CEF91F05B0FA80#)\n"
712       "      (Xp  #F7E943C7EF2169E930DCF23FE389EF7507EE8265\n"
713       "            0D42F4A0D3A3CEFABE367999BB30EE680B2FE064\n"
714       "            60F707F46005F8AA7CBFCDDC4814BBE7F0F8BC09\n"
715       "            318C8E51A48D134296E40D0BBDD282DCCBDDEE1D\n"
716       "            EC86F0B1C96EAFF5CDA70F9AEB6EE31E#)\n"
717       "      (Xq1 #11FDDA6E8128DC1629F75192BA#)\n"
718       "      (Xq2 #18AB178ECA907D72472F65E480#)\n"
719       "      (Xq  #C47560011412D6E13E3E7D007B5C05DBF5FF0D0F\n"
720       "            CFF1FA2070D16C7ABA93EDFB35D8700567E5913D\n"
721       "            B734E3FBD15862EBC59FA0425DFA131E549136E8\n"
722       "            E52397A8ABE4705EC4877D4F82C4AAC651B33DA6\n"
723       "            EA14B9D5F2A263DC65626E4D6CEAC767#))))\n",
724       "1FB56069985F18C4519694FB71055721A01F14422DC901C35B03A64D4A5BD1"
725       "259D573305F5B056AC931B82EDB084E39A0FD1D1A86CC5B147A264F7EF4EB2"
726       "0ED1E7FAAE5CAE4C30D5328B7F74C3CAA72C88B70DED8EDE207B8629DA2383"
727       "B78C3CE1CA3F9F218D78C938B35763AF2A8714664CC57F5CECE2413841F5E9"
728       "EDEC43B728E25A41BF3E1EF8D9EEE163286C9F8BF0F219D3B322C3E4B0389C"
729       "2E8BB28DC04C47DA2BF38823731266D2CF6CC3FC181738157624EF051874D0"
730       "BBCCB9F65C83"
731       /* Note that this example in X9.31 gives this value for D:
732
733         "7ED581A6617C6311465A53EDC4155C86807C5108B724070D6C0E9935296F44"
734         "96755CCC17D6C15AB24C6E0BB6C2138E683F4746A1B316C51E8993DFBD3AC8"
735         "3B479FEAB972B930C354CA2DFDD30F2A9CB222DC37B63B7881EE18A7688E0E"
736         "DE30F38728FE7C8635E324E2CD5D8EBCAA1C51993315FD73B38904E107D7A7"
737         "B7B10EDCA3896906FCF87BE367BB858CA1B27E2FC3C8674ECC8B0F92C0E270"
738         "BA2ECA3701311F68AFCE208DCC499B4B3DB30FF0605CE055D893BC1461D342"
739         "EF32E7D9720B"
740
741         This is a bug in X9.31, obviously introduced by using
742
743            d = e^{-1} mod (p-1)(q-1)
744
745          instead of using the universal exponent as required by 4.1.3:
746
747            d = e^{-1} mod lcm(p-1,q-1)
748
749          The examples in X9.31 seem to be pretty buggy, see
750          cipher/primegen.c for another bug.  Not only that I had to
751          spend 100 USD for the 66 pages of the document, it also took
752          me several hours to figure out that the bugs are in the
753          document and not in my code.
754        */
755     },
756
757     { /* First example from NIST RSAVS (B.1.1).  */
758       "(genkey\n"
759       "  (rsa\n"
760       "    (nbits 4:1024)\n"
761       "    (rsa-use-e 1:3)\n"
762       "    (derive-parms\n"
763       "      (Xp1 #1ed3d6368e101dab9124c92ac8#)\n"
764       "      (Xp2 #16e5457b8844967ce83cab8c11#)\n"
765       "      (Xp  #b79f2c2493b4b76f329903d7555b7f5f06aaa5ea\n"
766       "            ab262da1dcda8194720672a4e02229a0c71f60ae\n"
767       "            c4f0d2ed8d49ef583ca7d5eeea907c10801c302a\n"
768       "            cab44595#)\n"
769       "      (Xq1 #1a5d9e3fa34fb479bedea412f6#)\n"
770       "      (Xq2 #1f9cca85f185341516d92e82fd#)\n"
771       "      (Xq  #c8387fd38fa33ddcea6a9de1b2d55410663502db\n"
772       "            c225655a9310cceac9f4cf1bce653ec916d45788\n"
773       "            f8113c46bc0fa42bf5e8d0c41120c1612e2ea8bb\n"
774       "            2f389eda#))))\n",
775       "17ef7ad4fd96011b62d76dfb2261b4b3270ca8e07bc501be954f8719ef586b"
776       "f237e8f693dd16c23e7adecc40279dc6877c62ab541df5849883a5254fccfd"
777       "4072a657b7f4663953930346febd6bbd82f9a499038402cbf97fd5f068083a"
778       "c81ad0335c4aab0da19cfebe060a1bac7482738efafea078e21df785e56ea0"
779       "dc7e8feb"
780     },
781
782     { /* Second example from NIST RSAVS (B.1.1).  */
783       "(genkey\n"
784       "  (rsa\n"
785       "    (nbits 4:1536)\n"
786       "    (rsa-use-e 1:3)\n"
787       "    (derive-parms\n"
788       "      (Xp1 #1e64c1af460dff8842c22b64d0#)\n"
789       "      (Xp2 #1e948edcedba84039c81f2ac0c#)\n"
790       "      (Xp  #c8c67df894c882045ede26a9008ab09ea0672077\n"
791       "            d7bc71d412511cd93981ddde8f91b967da404056\n"
792       "            c39f105f7f239abdaff92923859920f6299e82b9\n"
793       "            5bd5b8c959948f4a034d81613d6235a3953b49ce\n"
794       "            26974eb7bb1f14843841281b363b9cdb#)\n"
795       "      (Xq1 #1f3df0f017ddd05611a97b6adb#)\n"
796       "      (Xq2 #143edd7b22d828913abf24ca4d#)\n"
797       "      (Xq  #f15147d0e7c04a1e3f37adde802cdc610999bf7a\n"
798       "            b0088434aaeda0c0ab3910b14d2ce56cb66bffd9\n"
799       "            7552195fae8b061077e03920814d8b9cfb5a3958\n"
800       "            b3a82c2a7fc97e55db543948d3396289245336ec\n"
801       "            9e3cb308cc655aebd766340da8921383#))))\n",
802       "1f8b19f3f5f2ac9fc599f110cad403dcd9bdf5f7f00fb2790e78e820398184"
803       "1f3fb3dd230fb223d898f45719d9b2d3525587ff2b8bcc7425e40550a5b536"
804       "1c8e9c1d26e83fbd9c33c64029c0e878b829d55def12912b73d94fd758c461"
805       "0f473e230c41b5e4c86e27c5a5029d82c811c88525d0269b95bd2ff272994a"
806       "dbd80f2c2ecf69065feb8abd8b445b9c6d306b1585d7d3d7576d49842bc7e2"
807       "8b4a2f88f4a47e71c3edd35fdf83f547ea5c2b532975c551ed5268f748b2c4"
808       "2ccf8a84835b"
809     }
810   };
811   gpg_error_t err;
812   gcry_sexp_t key_spec, key, pub_key, sec_key;
813   gcry_mpi_t d_expected, d_have;
814
815   if (what < 0 && what >= sizeof testtable)
816     die ("invalid WHAT value\n");
817
818   err = gcry_sexp_new (&key_spec, testtable[what].param, 0, 1);
819   if (err)
820     die ("error creating S-expression [%d]: %s\n", what, gpg_strerror (err));
821
822   err = gcry_pk_genkey (&key, key_spec);
823   gcry_sexp_release (key_spec);
824   if (err)
825     die ("error generating RSA key [%d]: %s\n", what, gpg_strerror (err));
826
827   pub_key = gcry_sexp_find_token (key, "public-key", 0);
828   if (!pub_key)
829     die ("public part missing in key [%d]\n", what);
830
831   sec_key = gcry_sexp_find_token (key, "private-key", 0);
832   if (!sec_key)
833     die ("private part missing in key [%d]\n", what);
834
835   err = gcry_mpi_scan
836     (&d_expected, GCRYMPI_FMT_HEX, testtable[what].expected_d, 0, NULL);
837   if (err)
838     die ("error converting string [%d]\n", what);
839
840   if (verbose > 1)
841     show_sexp ("generated key:\n", key);
842
843   d_have = key_param_from_sexp (sec_key, "rsa", "d");
844   if (!d_have)
845     die ("parameter d not found in RSA secret key [%d]\n", what);
846   if (gcry_mpi_cmp (d_expected, d_have))
847     {
848       show_sexp (NULL, sec_key);
849       die ("parameter d does match expected value [%d]\n", what);
850     }
851   gcry_mpi_release (d_expected);
852   gcry_mpi_release (d_have);
853
854   gcry_sexp_release (key);
855   gcry_sexp_release (pub_key);
856   gcry_sexp_release (sec_key);
857 }
858
859
860
861 static void
862 check_ecc_sample_key (void)
863 {
864   static const char ecc_private_key[] =
865     "(private-key\n"
866     " (ecdsa\n"
867     "  (curve \"NIST P-256\")\n"
868     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
869     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)\n"
870     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
871     "))";
872   static const char ecc_private_key_wo_q[] =
873     "(private-key\n"
874     " (ecdsa\n"
875     "  (curve \"NIST P-256\")\n"
876     "  (d #5A1EF0035118F19F3110FB81813D3547BCE1E5BCE77D1F744715E1D5BBE70378#)"
877     "))";
878   static const char ecc_public_key[] =
879     "(public-key\n"
880     " (ecdsa\n"
881     "  (curve \"NIST P-256\")\n"
882     "  (q #04D4F6A6738D9B8D3A7075C1E4EE95015FC0C9B7E4272D2BEB6644D3609FC781"
883     "B71F9A8072F58CB66AE2F89BB12451873ABF7D91F9E1FBF96BF2F70E73AAC9A283#)"
884     "))";
885   static const char hash_string[] =
886     "(data (flags raw)\n"
887     " (value #00112233445566778899AABBCCDDEEFF"
888     /* */    "000102030405060708090A0B0C0D0E0F#))";
889
890   gpg_error_t err;
891   gcry_sexp_t key, hash, sig;
892
893   if (verbose)
894     fprintf (stderr, "Checking sample ECC key.\n");
895
896   if ((err = gcry_sexp_new (&hash, hash_string, 0, 1)))
897     die ("line %d: %s", __LINE__, gpg_strerror (err));
898
899   if ((err = gcry_sexp_new (&key, ecc_private_key, 0, 1)))
900     die ("line %d: %s", __LINE__, gpg_strerror (err));
901
902   if ((err = gcry_pk_sign (&sig, hash, key)))
903     die ("gcry_pk_sign failed: %s", gpg_strerror (err));
904
905   gcry_sexp_release (key);
906   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
907     die ("line %d: %s", __LINE__, gpg_strerror (err));
908
909   if ((err = gcry_pk_verify (sig, hash, key)))
910     die ("gcry_pk_verify failed: %s", gpg_strerror (err));
911
912   /* Now try signing without the Q parameter.  */
913
914   gcry_sexp_release (key);
915   if ((err = gcry_sexp_new (&key, ecc_private_key_wo_q, 0, 1)))
916     die ("line %d: %s", __LINE__, gpg_strerror (err));
917
918   gcry_sexp_release (sig);
919   if ((err = gcry_pk_sign (&sig, hash, key)))
920     die ("gcry_pk_sign without Q failed: %s", gpg_strerror (err));
921
922   gcry_sexp_release (key);
923   if ((err = gcry_sexp_new (&key, ecc_public_key, 0, 1)))
924     die ("line %d: %s", __LINE__, gpg_strerror (err));
925
926   if ((err = gcry_pk_verify (sig, hash, key)))
927     die ("gcry_pk_verify signed without Q failed: %s", gpg_strerror (err));
928
929   gcry_sexp_release (sig);
930   gcry_sexp_release (key);
931   gcry_sexp_release (hash);
932 }
933
934
935 int
936 main (int argc, char **argv)
937 {
938   int debug = 0;
939   int i;
940
941   if (argc > 1 && !strcmp (argv[1], "--verbose"))
942     verbose = 1;
943   else if (argc > 1 && !strcmp (argv[1], "--debug"))
944     {
945       verbose = 2;
946       debug = 1;
947     }
948
949   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
950   if (!gcry_check_version (GCRYPT_VERSION))
951     die ("version mismatch\n");
952   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
953   if (debug)
954     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
955   /* No valuable keys are create, so we can speed up our RNG. */
956   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
957
958   for (i=0; i < 2; i++)
959     check_run ();
960
961   for (i=0; i < 4; i++)
962     check_x931_derived_key (i);
963
964   check_ecc_sample_key ();
965
966   return 0;
967 }