Add AES bulk CBC decryption selftest
[libgcrypt.git] / tests / pkcs1v2.c
1 /* pkcs1v2.c - Test OAEP and PSS padding
2  * Copyright (C) 2011 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 <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27
28 #ifdef _GCRYPT_IN_LIBGCRYPT
29 # include "../src/gcrypt.h"
30 #else
31 # include <gcrypt.h>
32 #endif
33
34
35 #define my_isascii(c) (!((c) & 0x80))
36 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
37 #define hexdigitp(a) (digitp (a)                     \
38                       || (*(a) >= 'A' && *(a) <= 'F')  \
39                       || (*(a) >= 'a' && *(a) <= 'f'))
40 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
41                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
42 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
43 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
44 #define DIMof(type,member)   DIM(((type *)0)->member)
45
46 static int verbose;
47 static int die_on_error;
48 static int error_count;
49
50
51 static void
52 info (const char *format, ...)
53 {
54   va_list arg_ptr;
55
56   va_start (arg_ptr, format);
57   vfprintf (stderr, format, arg_ptr);
58   va_end (arg_ptr);
59 }
60
61 static void
62 fail (const char *format, ...)
63 {
64   va_list arg_ptr;
65
66   va_start (arg_ptr, format);
67   vfprintf (stderr, format, arg_ptr);
68   va_end (arg_ptr);
69   error_count++;
70   if (die_on_error)
71     exit (1);
72 }
73
74 static void
75 die (const char *format, ...)
76 {
77   va_list arg_ptr;
78
79   va_start (arg_ptr, format);
80   vfprintf (stderr, format, arg_ptr);
81   va_end (arg_ptr);
82   exit (1);
83 }
84
85 static void
86 show_sexp (const char *prefix, gcry_sexp_t a)
87 {
88   char *buf;
89   size_t size;
90
91   if (prefix)
92     fputs (prefix, stderr);
93   size = gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, NULL, 0);
94   buf = gcry_xmalloc (size);
95
96   gcry_sexp_sprint (a, GCRYSEXP_FMT_ADVANCED, buf, size);
97   fprintf (stderr, "%.*s", (int)size, buf);
98   gcry_free (buf);
99 }
100
101
102 /* Convert STRING consisting of hex characters into its binary
103    representation and return it as an allocated buffer. The valid
104    length of the buffer is returned at R_LENGTH.  The string is
105    delimited by end of string.  The function returns NULL on
106    error.  */
107 static void *
108 data_from_hex (const char *string, size_t *r_length)
109 {
110   const char *s;
111   unsigned char *buffer;
112   size_t length;
113
114   buffer = gcry_xmalloc (strlen(string)/2+1);
115   length = 0;
116   for (s=string; *s; s +=2 )
117     {
118       if (!hexdigitp (s) || !hexdigitp (s+1))
119         die ("error parsing hex string `%s'\n", string);
120       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
121     }
122   *r_length = length;
123   return buffer;
124 }
125
126
127 static int
128 extract_cmp_data (gcry_sexp_t sexp, const char *name, const char *expected,
129                   const char *description)
130 {
131   gcry_sexp_t l1;
132   const void *a;
133   size_t alen;
134   void *b;
135   size_t blen;
136   int rc = 0;
137
138   l1 = gcry_sexp_find_token (sexp, name, 0);
139   a = gcry_sexp_nth_data (l1, 1, &alen);
140   b = data_from_hex (expected, &blen);
141   if (!a)
142     {
143       info ("%s: parameter \"%s\" missing in key\n", description, name);
144       rc = 1;
145     }
146   else if ( alen != blen || memcmp (a, b, alen) )
147     {
148       info ("%s: parameter \"%s\" does not match expected value\n",
149             description, name);
150       rc = 1;
151     }
152   gcry_free (b);
153   gcry_sexp_release (l1);
154   return rc;
155 }
156
157
158 /* Check against the OAEP test vectors from
159    ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip .  */
160 static void
161 check_oaep (void)
162 {
163 #include "pkcs1v2-oaep.h"
164   gpg_error_t err;
165   int tno, mno;
166
167   for (tno = 0; tno < DIM (tbl); tno++)
168     {
169       void *rsa_n, *rsa_e, *rsa_d;
170       size_t rsa_n_len, rsa_e_len, rsa_d_len;
171       gcry_sexp_t sec_key, pub_key;
172
173       if (verbose > 1)
174         info ("(%s)\n", tbl[tno].desc);
175
176       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
177       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
178       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
179       err = gcry_sexp_build (&sec_key, NULL,
180                              "(private-key (rsa (n %b)(e %b)(d %b)))",
181                              (int)rsa_n_len, rsa_n,
182                              (int)rsa_e_len, rsa_e,
183                              (int)rsa_d_len, rsa_d);
184       if (err)
185         die ("constructing private key failed: %s\n", gpg_strerror (err));
186       err = gcry_sexp_build (&pub_key, NULL,
187                              "(public-key (rsa (n %b)(e %b)))",
188                              (int)rsa_n_len, rsa_n,
189                              (int)rsa_e_len, rsa_e);
190       if (err)
191         die ("constructing public key failed: %s\n", gpg_strerror (err));
192       gcry_free (rsa_n);
193       gcry_free (rsa_e);
194       gcry_free (rsa_d);
195
196       for (mno = 0; mno < DIM (tbl[0].m); mno++)
197         {
198           void *mesg, *seed, *encr;
199           size_t mesg_len, seed_len, encr_len;
200           gcry_sexp_t plain, ciph;
201
202           if (verbose)
203             info ("running test: %s\n", tbl[tno].m[mno].desc);
204
205           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
206           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
207
208           err = gcry_sexp_build (&plain, NULL,
209                                  "(data (flags oaep)(hash-algo sha1)"
210                                  "(value %b)(random-override %b))",
211                                  (int)mesg_len, mesg,
212                                  (int)seed_len, seed);
213           if (err)
214             die ("constructing plain data failed: %s\n", gpg_strerror (err));
215           gcry_free (mesg);
216           gcry_free (seed);
217
218           err = gcry_pk_encrypt (&ciph, plain, pub_key);
219           if (err)
220             {
221               show_sexp ("plain:\n", ciph);
222               fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
223             }
224           else
225             {
226               if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
227                                     tbl[tno].m[mno].desc))
228                 {
229                   show_sexp ("encrypt result:\n", ciph);
230                   fail ("mismatch in gcry_pk_encrypt\n");
231                 }
232               gcry_sexp_release (ciph);
233               ciph = NULL;
234             }
235           gcry_sexp_release (plain);
236           plain = NULL;
237
238           /* Now test the decryption.  */
239           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
240           encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
241
242           err = gcry_sexp_build (&ciph, NULL,
243                                  "(enc-val (flags oaep)(hash-algo sha1)"
244                                  "(random-override %b)"
245                                  "(rsa (a %b)))",
246                                  (int)seed_len, seed,
247                                  (int)encr_len, encr);
248           if (err)
249             die ("constructing cipher data failed: %s\n", gpg_strerror (err));
250           gcry_free (encr);
251           gcry_free (seed);
252
253           err = gcry_pk_decrypt (&plain, ciph, sec_key);
254           if (err)
255             {
256               show_sexp ("ciph:\n", ciph);
257               fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
258             }
259           else
260             {
261               if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
262                                     tbl[tno].m[mno].desc))
263                 {
264                   show_sexp ("decrypt result:\n", plain);
265                   fail ("mismatch in gcry_pk_decrypt\n");
266                 }
267               gcry_sexp_release (plain);
268               plain = NULL;
269             }
270           gcry_sexp_release (ciph);
271           ciph = NULL;
272         }
273
274       gcry_sexp_release (sec_key);
275       gcry_sexp_release (pub_key);
276     }
277 }
278
279
280 /* Check against the PSS test vectors from
281    ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1d2-vec.zip .  */
282 static void
283 check_pss (void)
284 {
285 #include "pkcs1v2-pss.h"
286   gpg_error_t err;
287   int tno, mno;
288
289   for (tno = 0; tno < DIM (tbl); tno++)
290     {
291       void *rsa_n, *rsa_e, *rsa_d;
292       size_t rsa_n_len, rsa_e_len, rsa_d_len;
293       gcry_sexp_t sec_key, pub_key;
294
295       if (verbose > 1)
296         info ("(%s)\n", tbl[tno].desc);
297
298       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
299       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
300       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
301       err = gcry_sexp_build (&sec_key, NULL,
302                              "(private-key (rsa (n %b)(e %b)(d %b)))",
303                              (int)rsa_n_len, rsa_n,
304                              (int)rsa_e_len, rsa_e,
305                              (int)rsa_d_len, rsa_d);
306       if (err)
307         die ("constructing private key failed: %s\n", gpg_strerror (err));
308       err = gcry_sexp_build (&pub_key, NULL,
309                              "(public-key (rsa (n %b)(e %b)))",
310                              (int)rsa_n_len, rsa_n,
311                              (int)rsa_e_len, rsa_e);
312       if (err)
313         die ("constructing public key failed: %s\n", gpg_strerror (err));
314       gcry_free (rsa_n);
315       gcry_free (rsa_e);
316       gcry_free (rsa_d);
317
318       for (mno = 0; mno < DIM (tbl[0].m); mno++)
319         {
320           void *mesg, *salt, *sign;
321           size_t mesg_len, salt_len, sign_len;
322           gcry_sexp_t sigtmpl, sig;
323           char mhash[20];
324
325           if (verbose)
326             info ("running test: %s\n", tbl[tno].m[mno].desc);
327
328           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
329           salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
330
331           gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
332           err = gcry_sexp_build (&sigtmpl, NULL,
333                                  "(data (flags pss)"
334                                  "(hash sha1 %b)"
335                                  "(random-override %b))",
336                                  20, mhash,
337                                  (int)salt_len, salt);
338           if (err)
339             die ("constructing sig template failed: %s\n", gpg_strerror (err));
340           gcry_free (mesg);
341           gcry_free (salt);
342
343           err = gcry_pk_sign (&sig, sigtmpl, sec_key);
344           if (err)
345             {
346               show_sexp ("sigtmpl:\n", sigtmpl);
347               fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
348             }
349           else
350             {
351               if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
352                                     tbl[tno].m[mno].desc))
353                 {
354                   show_sexp ("sign result:\n", sig);
355                   fail ("mismatch in gcry_pk_sign\n");
356                 }
357               gcry_sexp_release (sig);
358               sig = NULL;
359             }
360           gcry_sexp_release (sigtmpl);
361           sigtmpl = NULL;
362
363           /* Now test the verification.  */
364           salt = data_from_hex (tbl[tno].m[mno].salt, &salt_len);
365           sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
366
367           err = gcry_sexp_build (&sig, NULL,
368                                  "(sig-val(rsa(s %b)))",
369                                  (int)sign_len, sign);
370           if (err)
371             die ("constructing verify data failed: %s\n", gpg_strerror (err));
372           err = gcry_sexp_build (&sigtmpl, NULL,
373                                  "(data (flags pss)"
374                                  "(hash sha1 %b)"
375                                  "(random-override %b))",
376                                  20, mhash,
377                                  (int)salt_len, salt);
378           if (err)
379             die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
380           gcry_free (sign);
381           gcry_free (salt);
382
383           err = gcry_pk_verify (sig, sigtmpl, pub_key);
384           if (err)
385             {
386               show_sexp ("sig:\n", sig);
387               show_sexp ("sigtmpl:\n", sigtmpl);
388               fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
389             }
390           gcry_sexp_release (sig);
391           sig = NULL;
392           gcry_sexp_release (sigtmpl);
393           sigtmpl = NULL;
394         }
395
396       gcry_sexp_release (sec_key);
397       gcry_sexp_release (pub_key);
398     }
399 }
400
401
402 /* Check against PKCS#1 v1.5 encryption test  vectors as found at
403    ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15crypt-vectors.txt .  */
404 static void
405 check_v15crypt (void)
406 {
407 #include "pkcs1v2-v15c.h"
408   gpg_error_t err;
409   int tno, mno;
410
411   for (tno = 0; tno < DIM (tbl); tno++)
412     {
413       void *rsa_n, *rsa_e, *rsa_d;
414       size_t rsa_n_len, rsa_e_len, rsa_d_len;
415       gcry_sexp_t sec_key, pub_key;
416
417       if (verbose > 1)
418         info ("(%s)\n", tbl[tno].desc);
419
420       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
421       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
422       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
423       err = gcry_sexp_build (&sec_key, NULL,
424                              "(private-key (rsa (n %b)(e %b)(d %b)))",
425                              (int)rsa_n_len, rsa_n,
426                              (int)rsa_e_len, rsa_e,
427                              (int)rsa_d_len, rsa_d);
428       if (err)
429         die ("constructing private key failed: %s\n", gpg_strerror (err));
430       err = gcry_sexp_build (&pub_key, NULL,
431                              "(public-key (rsa (n %b)(e %b)))",
432                              (int)rsa_n_len, rsa_n,
433                              (int)rsa_e_len, rsa_e);
434       if (err)
435         die ("constructing public key failed: %s\n", gpg_strerror (err));
436       gcry_free (rsa_n);
437       gcry_free (rsa_e);
438       gcry_free (rsa_d);
439
440       for (mno = 0; mno < DIM (tbl[0].m); mno++)
441         {
442           void *mesg, *seed, *encr;
443           size_t mesg_len, seed_len, encr_len;
444           gcry_sexp_t plain, ciph;
445
446           if (verbose)
447             info ("running test: %s\n", tbl[tno].m[mno].desc);
448
449           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
450           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
451
452           err = gcry_sexp_build (&plain, NULL,
453                                  "(data (flags pkcs1)(hash-algo sha1)"
454                                  "(value %b)(random-override %b))",
455                                  (int)mesg_len, mesg,
456                                  (int)seed_len, seed);
457           if (err)
458             die ("constructing plain data failed: %s\n", gpg_strerror (err));
459           gcry_free (mesg);
460           gcry_free (seed);
461
462           err = gcry_pk_encrypt (&ciph, plain, pub_key);
463           if (err)
464             {
465               show_sexp ("plain:\n", ciph);
466               fail ("gcry_pk_encrypt failed: %s\n", gpg_strerror (err));
467             }
468           else
469             {
470               if (extract_cmp_data (ciph, "a", tbl[tno].m[mno].encr,
471                                     tbl[tno].m[mno].desc))
472                 {
473                   show_sexp ("encrypt result:\n", ciph);
474                   fail ("mismatch in gcry_pk_encrypt\n");
475                 }
476               gcry_sexp_release (ciph);
477               ciph = NULL;
478             }
479           gcry_sexp_release (plain);
480           plain = NULL;
481
482           /* Now test the decryption.  */
483           seed = data_from_hex (tbl[tno].m[mno].seed, &seed_len);
484           encr = data_from_hex (tbl[tno].m[mno].encr, &encr_len);
485
486           err = gcry_sexp_build (&ciph, NULL,
487                                  "(enc-val (flags pkcs1)(hash-algo sha1)"
488                                  "(random-override %b)"
489                                  "(rsa (a %b)))",
490                                  (int)seed_len, seed,
491                                  (int)encr_len, encr);
492           if (err)
493             die ("constructing cipher data failed: %s\n", gpg_strerror (err));
494           gcry_free (encr);
495           gcry_free (seed);
496
497           err = gcry_pk_decrypt (&plain, ciph, sec_key);
498           if (err)
499             {
500               show_sexp ("ciph:\n", ciph);
501               fail ("gcry_pk_decrypt failed: %s\n", gpg_strerror (err));
502             }
503           else
504             {
505               if (extract_cmp_data (plain, "value", tbl[tno].m[mno].mesg,
506                                     tbl[tno].m[mno].desc))
507                 {
508                   show_sexp ("decrypt result:\n", plain);
509                   fail ("mismatch in gcry_pk_decrypt\n");
510                 }
511               gcry_sexp_release (plain);
512               plain = NULL;
513             }
514           gcry_sexp_release (ciph);
515           ciph = NULL;
516         }
517
518       gcry_sexp_release (sec_key);
519       gcry_sexp_release (pub_key);
520     }
521 }
522
523
524 /* Check against PKCS#1 v1.5 signature test vectors as found at
525    ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt .  */
526 static void
527 check_v15sign (void)
528 {
529 #include "pkcs1v2-v15s.h"
530   gpg_error_t err;
531   int tno, mno;
532
533   for (tno = 0; tno < DIM (tbl); tno++)
534     {
535       void *rsa_n, *rsa_e, *rsa_d;
536       size_t rsa_n_len, rsa_e_len, rsa_d_len;
537       gcry_sexp_t sec_key, pub_key;
538
539       if (verbose > 1)
540         info ("(%s)\n", tbl[tno].desc);
541
542       rsa_n = data_from_hex (tbl[tno].n, &rsa_n_len);
543       rsa_e = data_from_hex (tbl[tno].e, &rsa_e_len);
544       rsa_d = data_from_hex (tbl[tno].d, &rsa_d_len);
545       err = gcry_sexp_build (&sec_key, NULL,
546                              "(private-key (rsa (n %b)(e %b)(d %b)))",
547                              (int)rsa_n_len, rsa_n,
548                              (int)rsa_e_len, rsa_e,
549                              (int)rsa_d_len, rsa_d);
550       if (err)
551         die ("constructing private key failed: %s\n", gpg_strerror (err));
552       err = gcry_sexp_build (&pub_key, NULL,
553                              "(public-key (rsa (n %b)(e %b)))",
554                              (int)rsa_n_len, rsa_n,
555                              (int)rsa_e_len, rsa_e);
556       if (err)
557         die ("constructing public key failed: %s\n", gpg_strerror (err));
558       gcry_free (rsa_n);
559       gcry_free (rsa_e);
560       gcry_free (rsa_d);
561
562       for (mno = 0; mno < DIM (tbl[0].m); mno++)
563         {
564           void *mesg, *sign;
565           size_t mesg_len, sign_len;
566           gcry_sexp_t sigtmpl, sig;
567           char mhash[20];
568
569           if (verbose)
570             info ("running test: %s\n", tbl[tno].m[mno].desc);
571
572           mesg = data_from_hex (tbl[tno].m[mno].mesg, &mesg_len);
573
574           gcry_md_hash_buffer (GCRY_MD_SHA1, mhash, mesg, mesg_len);
575           err = gcry_sexp_build (&sigtmpl, NULL,
576                                  "(data (flags pkcs1)"
577                                  "(hash sha1 %b))",
578                                  20, mhash);
579           if (err)
580             die ("constructing sig template failed: %s\n", gpg_strerror (err));
581           gcry_free (mesg);
582
583           err = gcry_pk_sign (&sig, sigtmpl, sec_key);
584           if (err)
585             {
586               show_sexp ("sigtmpl:\n", sigtmpl);
587               fail ("gcry_pk_sign failed: %s\n", gpg_strerror (err));
588             }
589           else
590             {
591               if (extract_cmp_data (sig, "s", tbl[tno].m[mno].sign,
592                                     tbl[tno].m[mno].desc))
593                 {
594                   show_sexp ("sign result:\n", sig);
595                   fail ("mismatch in gcry_pk_sign\n");
596                 }
597               gcry_sexp_release (sig);
598               sig = NULL;
599             }
600           gcry_sexp_release (sigtmpl);
601           sigtmpl = NULL;
602
603           /* Now test the verification.  */
604           sign = data_from_hex (tbl[tno].m[mno].sign, &sign_len);
605
606           err = gcry_sexp_build (&sig, NULL,
607                                  "(sig-val(rsa(s %b)))",
608                                  (int)sign_len, sign);
609           if (err)
610             die ("constructing verify data failed: %s\n", gpg_strerror (err));
611           err = gcry_sexp_build (&sigtmpl, NULL,
612                                  "(data (flags pkcs1)"
613                                  "(hash sha1 %b))",
614                                  20, mhash);
615           if (err)
616             die ("constructing verify tmpl failed: %s\n", gpg_strerror (err));
617           gcry_free (sign);
618
619           err = gcry_pk_verify (sig, sigtmpl, pub_key);
620           if (err)
621             {
622               show_sexp ("sig:\n", sig);
623               show_sexp ("sigtmpl:\n", sigtmpl);
624               fail ("gcry_pk_verify failed: %s\n", gpg_strerror (err));
625             }
626           gcry_sexp_release (sig);
627           sig = NULL;
628           gcry_sexp_release (sigtmpl);
629           sigtmpl = NULL;
630         }
631
632       gcry_sexp_release (sec_key);
633       gcry_sexp_release (pub_key);
634     }
635 }
636
637
638 int
639 main (int argc, char **argv)
640 {
641   int last_argc = -1;
642   int debug = 0;
643   int run_oaep = 0;
644   int run_pss = 0;
645   int run_v15c = 0;
646   int run_v15s = 0;
647
648   if (argc)
649     { argc--; argv++; }
650
651   while (argc && last_argc != argc )
652     {
653       last_argc = argc;
654       if (!strcmp (*argv, "--"))
655         {
656           argc--; argv++;
657           break;
658         }
659       else if (!strcmp (*argv, "--verbose"))
660         {
661           verbose++;
662           argc--; argv++;
663         }
664       else if (!strcmp (*argv, "--debug"))
665         {
666           verbose = 2;
667           debug = 1;
668           argc--; argv++;
669         }
670       else if (!strcmp (*argv, "--die"))
671         {
672           die_on_error = 1;
673           argc--; argv++;
674         }
675       else if (!strcmp (*argv, "--oaep"))
676         {
677           run_oaep = 1;
678           argc--; argv++;
679         }
680       else if (!strcmp (*argv, "--pss"))
681         {
682           run_pss = 1;
683           argc--; argv++;
684         }
685       else if (!strcmp (*argv, "--v15c"))
686         {
687           run_v15c = 1;
688           argc--; argv++;
689         }
690       else if (!strcmp (*argv, "--v15s"))
691         {
692           run_v15s = 1;
693           argc--; argv++;
694         }
695     }
696
697   if (!run_oaep && !run_pss && !run_v15c && !run_v15s)
698     run_oaep = run_pss = run_v15c = run_v15s = 1;
699
700   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
701   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
702   if (!gcry_check_version ("1.5.0"))
703     die ("version mismatch\n");
704   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
705   if (debug)
706     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1u, 0);
707   /* No valuable keys are create, so we can speed up our RNG. */
708   gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
709
710   if (run_oaep)
711     check_oaep ();
712   if (run_pss)
713     check_pss ();
714   if (run_v15c)
715     check_v15crypt ();
716   if (run_v15s)
717     check_v15sign ();
718
719   if (verbose)
720     fprintf (stderr, "\nAll tests completed.  Errors: %i\n", error_count);
721
722   return error_count ? 1 : 0;
723 }