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