tests: Fix testsuite after the FIPS adjustments.
[libgcrypt.git] / tests / keygen.c
1 /* keygen.c  -  key generation regression tests
2  * Copyright (C) 2003, 2005, 2012 Free Software Foundation, Inc.
3  * Copyright (C) 2013, 2015 g10 Code GmbH
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include "../src/gcrypt-int.h"
29
30
31 #define PGM "keygen"
32
33 #define xmalloc(a)    gcry_xmalloc ((a))
34 #define xcalloc(a,b)  gcry_xcalloc ((a),(b))
35 #define xstrdup(a)    gcry_xstrdup ((a))
36 #define xfree(a)      gcry_free ((a))
37 #define pass()        do { ; } while (0)
38
39
40 static int verbose;
41 static int debug;
42 static int error_count;
43 static int in_fips_mode;
44
45
46 static void
47 die (const char *format, ...)
48 {
49   va_list arg_ptr ;
50
51   fflush (stdout);
52   fprintf (stderr, "%s: ", PGM);
53   va_start( arg_ptr, format ) ;
54   vfprintf (stderr, format, arg_ptr );
55   va_end(arg_ptr);
56   if (*format && format[strlen(format)-1] != '\n')
57     putc ('\n', stderr);
58   exit (1);
59 }
60
61 static void
62 fail (const char *format, ...)
63 {
64   va_list arg_ptr;
65
66   fflush (stdout);
67   fprintf (stderr, "%s: ", PGM);
68   /* if (wherestr) */
69   /*   fprintf (stderr, "%s: ", wherestr); */
70   va_start (arg_ptr, format);
71   vfprintf (stderr, format, arg_ptr);
72   va_end (arg_ptr);
73   if (*format && format[strlen(format)-1] != '\n')
74     putc ('\n', stderr);
75   error_count++;
76   if (error_count >= 50)
77     die ("stopped after 50 errors.");
78 }
79
80 static void
81 show (const char *format, ...)
82 {
83   va_list arg_ptr;
84
85   fprintf (stderr, "%s: ", PGM);
86   va_start (arg_ptr, format);
87   vfprintf (stderr, format, arg_ptr);
88   if (*format && format[strlen(format)-1] != '\n')
89     putc ('\n', stderr);
90   va_end (arg_ptr);
91 }
92
93
94 /* static void */
95 /* show_note (const char *format, ...) */
96 /* { */
97 /*   va_list arg_ptr; */
98
99 /*   if (!verbose && getenv ("srcdir")) */
100 /*     fputs ("      ", stderr);  /\* To align above "PASS: ".  *\/ */
101 /*   else */
102 /*     fprintf (stderr, "%s: ", PGM); */
103 /*   va_start (arg_ptr, format); */
104 /*   vfprintf (stderr, format, arg_ptr); */
105 /*   if (*format && format[strlen(format)-1] != '\n') */
106 /*     putc ('\n', stderr); */
107 /*   va_end (arg_ptr); */
108 /* } */
109
110
111 static void
112 show_sexp (const char *prefix, gcry_sexp_t a)
113 {
114   char *buf;
115   size_t size;
116
117   fprintf (stderr, "%s: ", PGM);
118   if (prefix)
119     fputs (prefix, stderr);
120   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
121   buf = xmalloc (size);
122
123   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
124   fprintf (stderr, "%.*s", (int)size, buf);
125   gcry_free (buf);
126 }
127
128
129 static void
130 show_mpi (const char *prefix, gcry_mpi_t a)
131 {
132   char *buf;
133   void *bufaddr = &buf;
134   gcry_error_t rc;
135
136   fprintf (stderr, "%s: ", PGM);
137   if (prefix)
138     fputs (prefix, stderr);
139   rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, bufaddr, NULL, a);
140   if (rc)
141     fprintf (stderr, "[error printing number: %s]\n",  gpg_strerror (rc));
142   else
143     {
144       fprintf (stderr, "%s\n", buf);
145       gcry_free (buf);
146     }
147 }
148
149
150 static void
151 check_generated_rsa_key (gcry_sexp_t key, unsigned long expected_e)
152 {
153   gcry_sexp_t skey, pkey, list;
154
155   pkey = gcry_sexp_find_token (key, "public-key", 0);
156   if (!pkey)
157     fail ("public part missing in return value\n");
158   else
159     {
160       gcry_mpi_t e = NULL;
161
162       list = gcry_sexp_find_token (pkey, "e", 0);
163       if (!list || !(e=gcry_sexp_nth_mpi (list, 1, 0)) )
164         fail ("public exponent not found\n");
165       else if (!expected_e)
166         {
167           if (verbose)
168             show_mpi ("public exponent: ", e);
169         }
170       else if ( gcry_mpi_cmp_ui (e, expected_e))
171         {
172           show_mpi ("public exponent: ", e);
173           fail ("public exponent is not %lu\n", expected_e);
174         }
175       gcry_sexp_release (list);
176       gcry_mpi_release (e);
177       gcry_sexp_release (pkey);
178     }
179
180   skey = gcry_sexp_find_token (key, "private-key", 0);
181   if (!skey)
182     fail ("private part missing in return value\n");
183   else
184     {
185       int rc = gcry_pk_testkey (skey);
186       if (rc)
187         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
188       gcry_sexp_release (skey);
189     }
190 }
191
192
193 static void
194 check_rsa_keys (void)
195 {
196   gcry_sexp_t keyparm, key;
197   int rc;
198
199   if (verbose)
200     show ("creating 2048 bit RSA key\n");
201   rc = gcry_sexp_new (&keyparm,
202                       "(genkey\n"
203                       " (rsa\n"
204                       "  (nbits 4:2048)\n"
205                       " ))", 0, 1);
206   if (rc)
207     die ("error creating S-expression: %s\n", gpg_strerror (rc));
208   rc = gcry_pk_genkey (&key, keyparm);
209   gcry_sexp_release (keyparm);
210   if (rc)
211     die ("error generating RSA key: %s\n", gpg_strerror (rc));
212
213   if (verbose)
214     show ("creating 1024 bit RSA key\n");
215   rc = gcry_sexp_new (&keyparm,
216                       "(genkey\n"
217                       " (rsa\n"
218                       "  (nbits 4:1024)\n"
219                       " ))", 0, 1);
220   if (rc)
221     die ("error creating S-expression: %s\n", gpg_strerror (rc));
222   rc = gcry_pk_genkey (&key, keyparm);
223   gcry_sexp_release (keyparm);
224   if (rc && !in_fips_mode)
225     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
226   else if (!rc && in_fips_mode)
227     fail ("generating 1024 bit RSA key must not work!");
228
229   if (!rc)
230     {
231       if (verbose > 1)
232         show_sexp ("1024 bit RSA key:\n", key);
233       check_generated_rsa_key (key, 65537);
234     }
235   gcry_sexp_release (key);
236
237
238   if (verbose)
239     show ("creating 512 bit RSA key with e=257\n");
240   rc = gcry_sexp_new (&keyparm,
241                       "(genkey\n"
242                       " (rsa\n"
243                       "  (nbits 3:512)\n"
244                       "  (rsa-use-e 3:257)\n"
245                       " ))", 0, 1);
246   if (rc)
247     die ("error creating S-expression: %s\n", gpg_strerror (rc));
248   rc = gcry_pk_genkey (&key, keyparm);
249   gcry_sexp_release (keyparm);
250   if (rc && !in_fips_mode)
251     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
252   else if (!rc && in_fips_mode)
253     fail ("generating 512 bit RSA key must not work!");
254
255   if (!rc)
256     check_generated_rsa_key (key, 257);
257   gcry_sexp_release (key);
258
259   if (verbose)
260     show ("creating 512 bit RSA key with default e\n");
261   rc = gcry_sexp_new (&keyparm,
262                       "(genkey\n"
263                       " (rsa\n"
264                       "  (nbits 3:512)\n"
265                       "  (rsa-use-e 1:0)\n"
266                       " ))", 0, 1);
267   if (rc)
268     die ("error creating S-expression: %s\n", gpg_strerror (rc));
269   rc = gcry_pk_genkey (&key, keyparm);
270   gcry_sexp_release (keyparm);
271   if (rc && !in_fips_mode)
272     fail ("error generating RSA key: %s\n", gpg_strerror (rc));
273   else if (!rc && in_fips_mode)
274     fail ("generating 512 bit RSA key must not work!");
275
276   if (!rc)
277     check_generated_rsa_key (key, 0); /* We don't expect a constant exponent. */
278   gcry_sexp_release (key);
279 }
280
281
282 static void
283 check_elg_keys (void)
284 {
285   gcry_sexp_t keyparm, key;
286   int rc;
287
288   if (verbose)
289     show ("creating 1024 bit Elgamal key\n");
290   rc = gcry_sexp_new (&keyparm,
291                       "(genkey\n"
292                       " (elg\n"
293                       "  (nbits 4:1024)\n"
294                       " ))", 0, 1);
295   if (rc)
296     die ("error creating S-expression: %s\n", gpg_strerror (rc));
297   rc = gcry_pk_genkey (&key, keyparm);
298   gcry_sexp_release (keyparm);
299   if (rc)
300     die ("error generating Elgamal key: %s\n", gpg_strerror (rc));
301   if (verbose > 1)
302     show_sexp ("1024 bit Elgamal key:\n", key);
303   gcry_sexp_release (key);
304 }
305
306
307 static void
308 check_dsa_keys (void)
309 {
310   gcry_sexp_t keyparm, key;
311   int rc;
312   int i;
313
314   /* Check that DSA generation works and that it can grok the qbits
315      argument. */
316   if (verbose)
317     show ("creating 5 1024 bit DSA keys\n");
318   for (i=0; i < 5; i++)
319     {
320       rc = gcry_sexp_new (&keyparm,
321                           "(genkey\n"
322                           " (dsa\n"
323                           "  (nbits 4:1024)\n"
324                           " ))", 0, 1);
325       if (rc)
326         die ("error creating S-expression: %s\n", gpg_strerror (rc));
327       rc = gcry_pk_genkey (&key, keyparm);
328       gcry_sexp_release (keyparm);
329       if (rc && !in_fips_mode)
330         die ("error generating DSA key: %s\n", gpg_strerror (rc));
331       else if (!rc && in_fips_mode)
332         die ("generating 1024 bit DSA key must not work!");
333       if (!i && verbose > 1)
334         show_sexp ("1024 bit DSA key:\n", key);
335       gcry_sexp_release (key);
336     }
337
338   if (verbose)
339     show ("creating 1536 bit DSA key\n");
340   rc = gcry_sexp_new (&keyparm,
341                       "(genkey\n"
342                       " (dsa\n"
343                       "  (nbits 4:1536)\n"
344                       "  (qbits 3:224)\n"
345                       " ))", 0, 1);
346   if (rc)
347     die ("error creating S-expression: %s\n", gpg_strerror (rc));
348   rc = gcry_pk_genkey (&key, keyparm);
349   gcry_sexp_release (keyparm);
350   if (rc && !in_fips_mode)
351     die ("error generating DSA key: %s\n", gpg_strerror (rc));
352   else if (!rc && in_fips_mode)
353     die ("generating 1536 bit DSA key must not work!");
354   if (verbose > 1)
355     show_sexp ("1536 bit DSA key:\n", key);
356   gcry_sexp_release (key);
357
358   if (verbose)
359     show ("creating 3072 bit DSA key\n");
360   rc = gcry_sexp_new (&keyparm,
361                       "(genkey\n"
362                       " (dsa\n"
363                       "  (nbits 4:3072)\n"
364                       "  (qbits 3:256)\n"
365                       " ))", 0, 1);
366   if (rc)
367     die ("error creating S-expression: %s\n", gpg_strerror (rc));
368   rc = gcry_pk_genkey (&key, keyparm);
369   gcry_sexp_release (keyparm);
370   if (rc)
371     die ("error generating DSA key: %s\n", gpg_strerror (rc));
372   if (verbose > 1)
373     show_sexp ("3072 bit DSA key:\n", key);
374   gcry_sexp_release (key);
375
376   if (verbose)
377     show ("creating 2048/256 bit DSA key\n");
378   rc = gcry_sexp_new (&keyparm,
379                       "(genkey\n"
380                       " (dsa\n"
381                       "  (nbits 4:2048)\n"
382                       "  (qbits 3:256)\n"
383                       " ))", 0, 1);
384   if (rc)
385     die ("error creating S-expression: %s\n", gpg_strerror (rc));
386   rc = gcry_pk_genkey (&key, keyparm);
387   gcry_sexp_release (keyparm);
388   if (rc)
389     die ("error generating DSA key: %s\n", gpg_strerror (rc));
390   if (verbose > 1)
391     show_sexp ("2048 bit DSA key:\n", key);
392   gcry_sexp_release (key);
393
394   if (verbose)
395     show ("creating 2048/224 bit DSA key\n");
396   rc = gcry_sexp_new (&keyparm,
397                       "(genkey\n"
398                       " (dsa\n"
399                       "  (nbits 4:2048)\n"
400                       "  (qbits 3:224)\n"
401                       " ))", 0, 1);
402   if (rc)
403     die ("error creating S-expression: %s\n", gpg_strerror (rc));
404   rc = gcry_pk_genkey (&key, keyparm);
405   gcry_sexp_release (keyparm);
406   if (rc)
407     die ("error generating DSA key: %s\n", gpg_strerror (rc));
408   if (verbose > 1)
409     show_sexp ("2048 bit DSA key:\n", key);
410   gcry_sexp_release (key);
411 }
412
413
414 static void
415 check_generated_ecc_key (gcry_sexp_t key)
416 {
417   gcry_sexp_t skey, pkey;
418
419   pkey = gcry_sexp_find_token (key, "public-key", 0);
420   if (!pkey)
421     fail ("public part missing in return value\n");
422   else
423     {
424       /* Fixme: Check more stuff.  */
425       gcry_sexp_release (pkey);
426     }
427
428   skey = gcry_sexp_find_token (key, "private-key", 0);
429   if (!skey)
430     fail ("private part missing in return value\n");
431   else
432     {
433       int rc = gcry_pk_testkey (skey);
434       if (rc)
435         fail ("gcry_pk_testkey failed: %s\n", gpg_strerror (rc));
436       gcry_sexp_release (skey);
437     }
438
439   /* Finally check that gcry_pk_testkey also works on the entire
440      S-expression.  */
441   {
442     int rc = gcry_pk_testkey (key);
443     if (rc)
444       fail ("gcry_pk_testkey failed on key pair: %s\n", gpg_strerror (rc));
445   }
446 }
447
448
449 static void
450 check_ecc_keys (void)
451 {
452   const char *curves[] = { "NIST P-521", "NIST P-384", "NIST P-256",
453                            "Ed25519", NULL };
454   int testno;
455   gcry_sexp_t keyparm, key;
456   int rc;
457
458   for (testno=0; curves[testno]; testno++)
459     {
460       if (verbose)
461         show ("creating ECC key using curve %s\n", curves[testno]);
462       if (!strcmp (curves[testno], "Ed25519"))
463         {
464           /* Ed25519 isn't allowed in fips mode */
465           if (in_fips_mode)
466             continue;
467           rc = gcry_sexp_build (&keyparm, NULL,
468                                 "(genkey(ecc(curve %s)(flags param eddsa)))",
469                                 curves[testno]);
470         }
471       else
472         rc = gcry_sexp_build (&keyparm, NULL,
473                               "(genkey(ecc(curve %s)(flags param)))",
474                               curves[testno]);
475       if (rc)
476         die ("error creating S-expression: %s\n", gpg_strerror (rc));
477       rc = gcry_pk_genkey (&key, keyparm);
478       gcry_sexp_release (keyparm);
479       if (rc)
480         die ("error generating ECC key using curve %s: %s\n",
481              curves[testno], gpg_strerror (rc));
482
483       if (verbose > 1)
484         show_sexp ("ECC key:\n", key);
485
486       check_generated_ecc_key (key);
487
488       gcry_sexp_release (key);
489     }
490
491   if (verbose)
492     show ("creating ECC key using curve Ed25519 for ECDSA\n");
493   rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve Ed25519)))");
494   if (rc)
495     die ("error creating S-expression: %s\n", gpg_strerror (rc));
496   rc = gcry_pk_genkey (&key, keyparm);
497   gcry_sexp_release (keyparm);
498   if (rc)
499     die ("error generating ECC key using curve Ed25519 for ECDSA: %s\n",
500          gpg_strerror (rc));
501
502   if (verbose > 1)
503     show_sexp ("ECC key:\n", key);
504
505   check_generated_ecc_key (key);
506   gcry_sexp_release (key);
507
508   if (verbose)
509     show ("creating ECC key using curve Ed25519 for ECDSA (nocomp)\n");
510   rc = gcry_sexp_build (&keyparm, NULL,
511                         "(genkey(ecc(curve Ed25519)(flags nocomp)))");
512   if (rc)
513     die ("error creating S-expression: %s\n", gpg_strerror (rc));
514   rc = gcry_pk_genkey (&key, keyparm);
515   gcry_sexp_release (keyparm);
516   if (rc)
517     die ("error generating ECC key using curve Ed25519 for ECDSA"
518          " (nocomp): %s\n",
519          gpg_strerror (rc));
520
521   if (verbose)
522     show ("creating ECC key using curve NIST P-384 for ECDSA\n");
523
524   /* Must be specified as nistp384 (one word), because ecc_generate
525    * uses _gcry_sexp_nth_string which takes the first word of the name
526    * and thus libgcrypt can't find it later in its curves table.  */
527   rc = gcry_sexp_build (&keyparm, NULL, "(genkey(ecc(curve nistp384)))");
528   if (rc)
529     die ("error creating S-expression: %s\n", gpg_strerror (rc));
530   rc = gcry_pk_genkey (&key, keyparm);
531   gcry_sexp_release (keyparm);
532   if (rc)
533     die ("error generating ECC key using curve NIST P-384 for ECDSA: %s\n",
534          gpg_strerror (rc));
535
536   if (verbose > 1)
537     show_sexp ("ECC key:\n", key);
538
539   check_generated_ecc_key (key);
540   gcry_sexp_release (key);
541
542   if (verbose)
543     show ("creating ECC key using curve NIST P-384 for ECDSA (nocomp)\n");
544   rc = gcry_sexp_build (&keyparm, NULL,
545                         "(genkey(ecc(curve nistp384)(flags nocomp)))");
546   if (rc)
547     die ("error creating S-expression: %s\n", gpg_strerror (rc));
548   rc = gcry_pk_genkey (&key, keyparm);
549   gcry_sexp_release (keyparm);
550   if (rc)
551     die ("error generating ECC key using curve NIST P-384 for ECDSA"
552          " (nocomp): %s\n",
553          gpg_strerror (rc));
554
555   if (verbose > 1)
556     show_sexp ("ECC key:\n", key);
557
558   check_generated_ecc_key (key);
559   gcry_sexp_release (key);
560
561
562   if (verbose)
563     show ("creating ECC key using curve Ed25519 for ECDSA (transient-key)\n");
564   rc = gcry_sexp_build (&keyparm, NULL,
565                         "(genkey(ecc(curve Ed25519)(flags transient-key)))");
566   if (rc)
567     die ("error creating S-expression: %s\n", gpg_strerror (rc));
568   rc = gcry_pk_genkey (&key, keyparm);
569   gcry_sexp_release (keyparm);
570   if (rc)
571     die ("error generating ECC key using curve Ed25519 for ECDSA"
572          " (transient-key): %s\n",
573          gpg_strerror (rc));
574   if (verbose > 1)
575     show_sexp ("ECC key:\n", key);
576   check_generated_ecc_key (key);
577   gcry_sexp_release (key);
578
579   if (verbose)
580     show ("creating ECC key using curve Ed25519 for ECDSA "
581           "(transient-key no-keytest)\n");
582   rc = gcry_sexp_build (&keyparm, NULL,
583                         "(genkey(ecc(curve Ed25519)"
584                         "(flags transient-key no-keytest)))");
585   if (rc)
586     die ("error creating S-expression: %s\n", gpg_strerror (rc));
587   rc = gcry_pk_genkey (&key, keyparm);
588   gcry_sexp_release (keyparm);
589   if (rc)
590     die ("error generating ECC key using curve Ed25519 for ECDSA"
591          " (transient-key no-keytest): %s\n",
592          gpg_strerror (rc));
593   if (verbose > 1)
594     show_sexp ("ECC key:\n", key);
595   check_generated_ecc_key (key);
596   gcry_sexp_release (key);
597 }
598
599
600 static void
601 check_nonce (void)
602 {
603   char a[32], b[32];
604   int i,j;
605   int oops=0;
606
607   if (verbose)
608     show ("checking gcry_create_nonce\n");
609
610   gcry_create_nonce (a, sizeof a);
611   for (i=0; i < 10; i++)
612     {
613       gcry_create_nonce (b, sizeof b);
614       if (!memcmp (a, b, sizeof a))
615         die ("identical nonce found\n");
616     }
617   for (i=0; i < 10; i++)
618     {
619       gcry_create_nonce (a, sizeof a);
620       if (!memcmp (a, b, sizeof a))
621         die ("identical nonce found\n");
622     }
623
624  again:
625   for (i=1,j=0; i < sizeof a; i++)
626     if (a[0] == a[i])
627       j++;
628   if (j+1 == sizeof (a))
629     {
630       if (oops)
631         die ("impossible nonce found\n");
632       oops++;
633       gcry_create_nonce (a, sizeof a);
634       goto again;
635     }
636 }
637
638
639 static void
640 progress_cb (void *cb_data, const char *what, int printchar,
641                   int current, int total)
642 {
643   (void)cb_data;
644   (void)what;
645   (void)current;
646   (void)total;
647
648   if (printchar == '\n')
649     fputs ( "<LF>", stdout);
650   else
651     putchar (printchar);
652   fflush (stdout);
653 }
654
655
656 static void
657 usage (int mode)
658 {
659   fputs ("usage: " PGM " [options] [{rsa|elg|dsa|ecc|nonce}]\n"
660          "Options:\n"
661          "  --verbose       be verbose\n"
662          "  --debug         flyswatter\n"
663          "  --progress      print progress indicators\n",
664          mode? stderr : stdout);
665   if (mode)
666     exit (1);
667 }
668
669 int
670 main (int argc, char **argv)
671 {
672   int last_argc = -1;
673   int with_progress = 0;
674
675   if (argc)
676     { argc--; argv++; }
677
678   while (argc && last_argc != argc )
679     {
680       last_argc = argc;
681       if (!strcmp (*argv, "--"))
682         {
683           argc--; argv++;
684           break;
685         }
686       else if (!strcmp (*argv, "--help"))
687         {
688           usage (0);
689           exit (0);
690         }
691       else if (!strcmp (*argv, "--verbose"))
692         {
693           verbose++;
694           argc--; argv++;
695         }
696       else if (!strcmp (*argv, "--debug"))
697         {
698           verbose += 2;
699           debug++;
700           argc--; argv++;
701         }
702       else if (!strcmp (*argv, "--progress"))
703         {
704           argc--; argv++;
705           with_progress = 1;
706         }
707       else if (!strncmp (*argv, "--", 2))
708         die ("unknown option '%s'", *argv);
709       else
710         break;
711     }
712
713   if (!gcry_check_version (GCRYPT_VERSION))
714     die ("version mismatch\n");
715   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
716   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
717   if (debug)
718     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u , 0);
719   /* No valuable keys are create, so we can speed up our RNG. */
720   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
721   if (with_progress)
722     gcry_set_progress_handler (progress_cb, NULL);
723
724   if ( gcry_fips_mode_active () )
725     in_fips_mode = 1;
726
727   if (!argc)
728     {
729       check_rsa_keys ();
730       check_elg_keys ();
731       check_dsa_keys ();
732       check_ecc_keys ();
733       check_nonce ();
734     }
735   else
736     {
737       for (; argc; argc--, argv++)
738         if (!strcmp (*argv, "rsa"))
739           check_rsa_keys ();
740         else if (!strcmp (*argv, "elg"))
741           check_elg_keys ();
742         else if (!strcmp (*argv, "dsa"))
743           check_dsa_keys ();
744         else if (!strcmp (*argv, "ecc"))
745           check_ecc_keys ();
746         else if (!strcmp (*argv, "nonce"))
747           check_nonce ();
748         else
749           usage (1);
750     }
751
752   return error_count? 1:0;
753 }