Fixed the fips 186 dsa key generation.
[libgcrypt.git] / tests / fipsdrv.c
1 /* fipsdrv.c  -  A driver to help with FIPS CAVS tests.
2    Copyright (C) 2008 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 #include <errno.h>
28 #include <ctype.h>
29 #ifndef HAVE_W32_SYSTEM
30 # include <signal.h>
31 #endif
32 #include <assert.h>
33 #include <unistd.h>
34
35 #include <gcrypt.h>
36
37 #define PGM "fipsdrv"
38
39 #define my_isascii(c) (!((c) & 0x80))
40 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
41 #define hexdigitp(a) (digitp (a)                     \
42                       || (*(a) >= 'A' && *(a) <= 'F')  \
43                       || (*(a) >= 'a' && *(a) <= 'f'))
44 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
45                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
46 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
47 #define DIM(v)               (sizeof(v)/sizeof((v)[0]))
48 #define DIMof(type,member)   DIM(((type *)0)->member)
49
50
51 #define PRIV_CTL_INIT_EXTRNG_TEST   58
52 #define PRIV_CTL_RUN_EXTRNG_TEST    59
53 #define PRIV_CTL_DEINIT_EXTRNG_TEST 60
54 #define PRIV_CTL_DISABLE_WEAK_KEY   61
55 #define PRIV_CTL_GET_INPUT_VECTOR   62
56
57
58 /* Verbose mode flag.  */
59 static int verbose;
60
61 /* Binary input flag.  */
62 static int binary_input;
63
64 /* Binary output flag.  */
65 static int binary_output;
66
67 /* Base64 output flag.  */
68 static int base64_output;
69
70 /* We need to know whetehr we are in loop_mode.  */
71 static int loop_mode;
72
73
74 /* ASN.1 classes.  */
75 enum
76 {
77   UNIVERSAL = 0,
78   APPLICATION = 1,
79   ASNCONTEXT = 2,
80   PRIVATE = 3
81 };
82
83
84 /* ASN.1 tags.  */
85 enum
86 {
87   TAG_NONE = 0,
88   TAG_BOOLEAN = 1,
89   TAG_INTEGER = 2,
90   TAG_BIT_STRING = 3,
91   TAG_OCTET_STRING = 4,
92   TAG_NULL = 5,
93   TAG_OBJECT_ID = 6,
94   TAG_OBJECT_DESCRIPTOR = 7,
95   TAG_EXTERNAL = 8,
96   TAG_REAL = 9,
97   TAG_ENUMERATED = 10,
98   TAG_EMBEDDED_PDV = 11,
99   TAG_UTF8_STRING = 12,
100   TAG_REALTIVE_OID = 13,
101   TAG_SEQUENCE = 16,
102   TAG_SET = 17,
103   TAG_NUMERIC_STRING = 18,
104   TAG_PRINTABLE_STRING = 19,
105   TAG_TELETEX_STRING = 20,
106   TAG_VIDEOTEX_STRING = 21,
107   TAG_IA5_STRING = 22,
108   TAG_UTC_TIME = 23,
109   TAG_GENERALIZED_TIME = 24,
110   TAG_GRAPHIC_STRING = 25,
111   TAG_VISIBLE_STRING = 26,
112   TAG_GENERAL_STRING = 27,
113   TAG_UNIVERSAL_STRING = 28,
114   TAG_CHARACTER_STRING = 29,
115   TAG_BMP_STRING = 30
116 };
117
118 /* ASN.1 Parser object.  */
119 struct tag_info 
120 {
121   int class;             /* Object class.  */
122   unsigned long tag;     /* The tag of the object.  */
123   unsigned long length;  /* Length of the values.  */
124   int nhdr;              /* Length of the header (TL).  */
125   unsigned int ndef:1;   /* The object has an indefinite length.  */
126   unsigned int cons:1;   /* This is a constructed object.  */ 
127 };
128
129
130
131 /* Print a error message and exit the process with an error code.  */
132 static void
133 die (const char *format, ...)
134 {
135   va_list arg_ptr;
136
137   va_start (arg_ptr, format);
138   fputs (PGM ": ", stderr);
139   vfprintf (stderr, format, arg_ptr);
140   va_end (arg_ptr);
141   exit (1);
142 }
143
144
145 static void
146 showhex (const char *prefix, const void *buffer, size_t length)
147 {
148   const unsigned char *p = buffer;
149
150   if (prefix)
151     fprintf (stderr, PGM ": %s: ", prefix);
152   while (length-- )
153     fprintf (stderr, "%02X", *p++);
154   if (prefix)
155     putc ('\n', stderr);
156 }
157
158
159 /* Convert STRING consisting of hex characters into its binary
160    representation and store that at BUFFER.  BUFFER needs to be of
161    LENGTH bytes.  The function checks that the STRING will convert
162    exactly to LENGTH bytes. The string is delimited by either end of
163    string or a white space character.  The function returns -1 on
164    error or the length of the parsed string.  */
165 static int
166 hex2bin (const char *string, void *buffer, size_t length)
167 {
168   int i;
169   const char *s = string;
170
171   for (i=0; i < length; )
172     {
173       if (!hexdigitp (s) || !hexdigitp (s+1))
174         return -1;           /* Invalid hex digits. */
175       ((unsigned char*)buffer)[i++] = xtoi_2 (s);
176       s += 2;
177     }
178   if (*s && (!my_isascii (*s) || !isspace (*s)) )
179     return -1;             /* Not followed by Nul or white space.  */
180   if (i != length)
181     return -1;             /* Not of expected length.  */
182   if (*s)
183     s++; /* Skip the delimiter. */
184   return s - string;
185 }
186
187
188 /* Convert STRING consisting of hex characters into its binary
189    representation and return it as an allocated buffer. The valid
190    length of the buffer is returned at R_LENGTH.  The string is
191    delimited by end of string.  The function returns NULL on
192    error.  */
193 static void *
194 hex2buffer (const char *string, size_t *r_length)
195 {
196   const char *s;
197   unsigned char *buffer;
198   size_t length;
199
200   buffer = gcry_xmalloc (strlen(string)/2+1);
201   length = 0;
202   for (s=string; *s; s +=2 )
203     {
204       if (!hexdigitp (s) || !hexdigitp (s+1))
205         return NULL;           /* Invalid hex digits. */
206       ((unsigned char*)buffer)[length++] = xtoi_2 (s);
207     }
208   *r_length = length;
209   return buffer;
210 }
211
212
213 static char *
214 read_textline (FILE *fp)
215 {
216   char line[256];
217   char *p;
218   int any = 0;
219
220   /* Read line but skip over initial empty lines.  */
221   do
222     {
223       do 
224         {
225           if (!fgets (line, sizeof line, fp))
226             {
227               if (feof (fp))
228                 return NULL;
229               die ("error reading input line: %s\n", strerror (errno));
230             }
231           p = strchr (line, '\n');
232           if (p)
233             *p = 0;
234           p = line + (*line? (strlen (line)-1):0);
235           for ( ;p > line; p--)
236             if (my_isascii (*p) && isspace (*p))
237               *p = 0;
238         }
239       while (!any && !*line);
240       any = 1;
241     }
242   while (*line == '#');  /* Always skip comment lines.  */
243   if (verbose > 1)
244     fprintf (stderr, PGM ": received line: %s\n", line);
245   return gcry_xstrdup (line);
246 }
247
248 static char *
249 read_hexline (FILE *fp, size_t *retlen)
250 {
251   char *line, *p;
252
253   line = read_textline (fp);
254   if (!line)
255     return NULL;
256   p = hex2buffer (line, retlen);
257   if (!p)
258     die ("error decoding hex string on input\n");
259   gcry_free (line);
260   return p;
261 }
262
263 static void
264 skip_to_empty_line (FILE *fp)
265 {
266   char line[256];
267   char *p;
268
269   do
270     {
271       if (!fgets (line, sizeof line, fp))
272         {
273           if (feof (fp))
274             return;
275           die ("error reading input line: %s\n", strerror (errno));
276         }
277       p = strchr (line, '\n');
278       if (p)
279         *p =0;
280     }
281   while (*line);
282 }
283
284
285
286 /* Read a file from stream FP into a newly allocated buffer and return
287    that buffer.  The valid length of the buffer is stored at R_LENGTH.
288    Returns NULL on failure.  If decode is set, the file is assumed to
289    be hex encoded and the decoded content is returned. */
290 static void *
291 read_file (FILE *fp, int decode, size_t *r_length)
292 {
293   char *buffer;
294   size_t buflen;
295   size_t nread, bufsize = 0;
296
297   *r_length = 0;
298 #define NCHUNK 8192
299 #ifdef HAVE_DOSISH_SYSTEM
300   setmode (fileno(fp), O_BINARY);
301 #endif
302   buffer = NULL;
303   buflen = 0;
304   do 
305     {
306       bufsize += NCHUNK;
307       if (!buffer)
308         buffer = gcry_xmalloc (bufsize);
309       else
310         buffer = gcry_xrealloc (buffer, bufsize);
311       
312       nread = fread (buffer + buflen, 1, NCHUNK, fp);
313       if (nread < NCHUNK && ferror (fp))
314         {
315           gcry_free (buffer);
316           return NULL;
317         }
318       buflen += nread;
319     }
320   while (nread == NCHUNK);
321 #undef NCHUNK
322   if (decode)
323     {
324       const char *s;
325       char *p;
326
327       for (s=buffer,p=buffer,nread=0; nread+1 < buflen; s += 2, nread +=2 )
328         {
329           if (!hexdigitp (s) || !hexdigitp (s+1))
330             {
331               gcry_free (buffer);
332               return NULL;  /* Invalid hex digits. */
333             }
334           *(unsigned char*)p++ = xtoi_2 (s);
335         }
336       if (nread != buflen)
337         {
338           gcry_free (buffer);
339           return NULL;  /* Odd number of hex digits. */
340         }
341       buflen = p - buffer;
342     }
343
344   *r_length = buflen;
345   return buffer;
346 }
347
348 /* Do in-place decoding of base-64 data of LENGTH in BUFFER.  Returns
349    the new length of the buffer.  Dies on error.  */
350 static size_t
351 base64_decode (char *buffer, size_t length)
352 {
353   static unsigned char const asctobin[128] = 
354     {
355       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
356       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
357       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
358       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
359       0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0xff, 0xff,
360       0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
361       0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12,
362       0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
363       0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24,
364       0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
365       0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff 
366     };
367
368   int idx = 0;
369   unsigned char val = 0;
370   int c = 0;
371   char *d, *s;
372   int lfseen = 1;
373
374   /* Find BEGIN line.  */
375   for (s=buffer; length; length--, s++)
376     {
377       if (lfseen && *s == '-' && length > 11 && !memcmp (s, "-----BEGIN ", 11))
378         {
379           for (; length && *s != '\n'; length--, s++)
380             ;
381           break;
382         } 
383       lfseen = (*s == '\n');
384     }
385
386   /* Decode until pad character or END line.  */
387   for (d=buffer; length; length--, s++)
388     {
389       if (lfseen && *s == '-' && length > 9 && !memcmp (s, "-----END ", 9))
390         break;
391       if ((lfseen = (*s == '\n')) || *s == ' ' || *s == '\r' || *s == '\t')
392         continue;
393       if (*s == '=')
394         {
395           /* Pad character: stop */
396           if (idx == 1)
397             *d++ = val;
398           break;
399         }
400
401       if ( (*s & 0x80) || (c = asctobin[*(unsigned char *)s]) == 0xff)
402         die ("invalid base64 character %02X at pos %d detected\n",
403              *(unsigned char*)s, (int)(s-buffer));
404
405       switch (idx)
406         {
407         case 0:
408           val = c << 2;
409           break;
410         case 1:
411           val |= (c>>4)&3;
412           *d++ = val;
413           val = (c<<4)&0xf0;
414           break;
415         case 2:
416           val |= (c>>2)&15;
417           *d++ = val;
418           val = (c<<6)&0xc0;
419           break;
420         case 3:
421           val |= c&0x3f;
422           *d++ = val;
423           break;
424         }
425       idx = (idx+1) % 4;
426     }
427
428   return d - buffer;
429 }
430
431
432 /* Parse the buffer at the address BUFFER which consists of the number
433    of octets as stored at BUFLEN.  Return the tag and the length part
434    from the TLV triplet.  Update BUFFER and BUFLEN on success.  Checks
435    that the encoded length does not exhaust the length of the provided
436    buffer. */
437 static int 
438 parse_tag (unsigned char const **buffer, size_t *buflen, struct tag_info *ti)
439 {
440   int c;
441   unsigned long tag;
442   const unsigned char *buf = *buffer;
443   size_t length = *buflen;
444
445   ti->length = 0;
446   ti->ndef = 0;
447   ti->nhdr = 0;
448
449   /* Get the tag */
450   if (!length)
451     return -1; /* Premature EOF.  */
452   c = *buf++; length--;
453   ti->nhdr++;
454
455   ti->class = (c & 0xc0) >> 6;
456   ti->cons  = !!(c & 0x20);
457   tag       = (c & 0x1f);
458
459   if (tag == 0x1f)
460     {
461       tag = 0;
462       do
463         {
464           tag <<= 7;
465           if (!length)
466             return -1; /* Premature EOF.  */
467           c = *buf++; length--;
468           ti->nhdr++;
469           tag |= (c & 0x7f);
470         }
471       while ( (c & 0x80) );
472     }
473   ti->tag = tag;
474
475   /* Get the length */
476   if (!length)
477     return -1; /* Premature EOF. */
478   c = *buf++; length--;
479   ti->nhdr++;
480
481   if ( !(c & 0x80) )
482     ti->length = c;
483   else if (c == 0x80)
484     ti->ndef = 1;
485   else if (c == 0xff)
486     return -1; /* Forbidden length value.  */
487   else
488     {
489       unsigned long len = 0;
490       int count = c & 0x7f;
491
492       for (; count; count--)
493         {
494           len <<= 8;
495           if (!length)
496             return -1; /* Premature EOF.  */
497           c = *buf++; length--;
498           ti->nhdr++;
499           len |= (c & 0xff);
500         }
501       ti->length = len;
502     }
503   
504   if (ti->class == UNIVERSAL && !ti->tag)
505     ti->length = 0;
506
507   if (ti->length > length)
508     return -1; /* Data larger than buffer.  */
509   
510   *buffer = buf;
511   *buflen = length;
512   return 0;
513 }
514
515
516 /* Read the file FNAME assuming it is a PEM encoded private key file
517    and return an S-expression.  With SHOW set, the key parameters are
518    printed.  */
519 static gcry_sexp_t
520 read_private_key_file (const char *fname, int show)
521 {
522   gcry_error_t err;
523   FILE *fp;
524   char *buffer;
525   size_t buflen;
526   const unsigned char *der;
527   size_t derlen;
528   struct tag_info ti;
529   gcry_mpi_t keyparms[8];
530   int n_keyparms = 8;
531   int idx;
532   gcry_sexp_t s_key;
533
534   fp = fopen (fname, binary_input?"rb":"r");
535   if (!fp)
536     die ("can't open `%s': %s\n", fname, strerror (errno));
537   buffer = read_file (fp, 0, &buflen);
538   if (!buffer)
539     die ("error reading `%s'\n", fname);
540   fclose (fp);
541
542   buflen = base64_decode (buffer, buflen);
543   
544   /* Parse the ASN.1 structure.  */
545   der = (const unsigned char*)buffer;
546   derlen = buflen;
547   if ( parse_tag (&der, &derlen, &ti)
548        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
549     goto bad_asn1;
550   if ( parse_tag (&der, &derlen, &ti)
551        || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
552     goto bad_asn1;
553   if (ti.length != 1 || *der)
554     goto bad_asn1;  /* The value of the first integer is no 0. */
555   der += ti.length; derlen -= ti.length;
556
557   for (idx=0; idx < n_keyparms; idx++)
558     {
559       if ( parse_tag (&der, &derlen, &ti)
560            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
561         goto bad_asn1;
562       if (show)
563         {
564           char prefix[2];
565
566           prefix[0] = idx < 8? "nedpq12u"[idx] : '?';
567           prefix[1] = 0;
568           showhex (prefix, der, ti.length);
569         }
570       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
571       if (err)
572         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
573       der += ti.length; derlen -= ti.length;
574     }
575   if (idx != n_keyparms)
576     die ("not enough RSA key parameters\n");
577
578   gcry_free (buffer);
579
580   /* Convert from OpenSSL parameter ordering to the OpenPGP order. */
581   /* First check that p < q; if not swap p and q and recompute u.  */ 
582   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
583     {
584       gcry_mpi_swap (keyparms[3], keyparms[4]);
585       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
586     }
587   
588   /* Build the S-expression.  */
589   err = gcry_sexp_build (&s_key, NULL,
590                          "(private-key(rsa(n%m)(e%m)"
591                          /**/            "(d%m)(p%m)(q%m)(u%m)))",
592                          keyparms[0], keyparms[1], keyparms[2],
593                          keyparms[3], keyparms[4], keyparms[7] );
594   if (err)
595     die ("error building S-expression: %s\n", gpg_strerror (err));
596   
597   for (idx=0; idx < n_keyparms; idx++)
598     gcry_mpi_release (keyparms[idx]);
599   
600   return s_key;
601   
602  bad_asn1:
603   die ("invalid ASN.1 structure in `%s'\n", fname);
604   return NULL; /*NOTREACHED*/
605 }
606
607
608 /* Read the file FNAME assuming it is a PEM encoded public key file
609    and return an S-expression.  With SHOW set, the key parameters are
610    printed.  */
611 static gcry_sexp_t
612 read_public_key_file (const char *fname, int show)
613 {
614   gcry_error_t err;
615   FILE *fp;
616   char *buffer;
617   size_t buflen;
618   const unsigned char *der;
619   size_t derlen;
620   struct tag_info ti;
621   gcry_mpi_t keyparms[2];
622   int n_keyparms = 2;
623   int idx;
624   gcry_sexp_t s_key;
625
626   fp = fopen (fname, binary_input?"rb":"r");
627   if (!fp)
628     die ("can't open `%s': %s\n", fname, strerror (errno));
629   buffer = read_file (fp, 0, &buflen);
630   if (!buffer)
631     die ("error reading `%s'\n", fname);
632   fclose (fp);
633
634   buflen = base64_decode (buffer, buflen);
635   
636   /* Parse the ASN.1 structure.  */
637   der = (const unsigned char*)buffer;
638   derlen = buflen;
639   if ( parse_tag (&der, &derlen, &ti)
640        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
641     goto bad_asn1;
642   if ( parse_tag (&der, &derlen, &ti)
643        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
644     goto bad_asn1;
645   /* We skip the description of the key parameters and assume it is RSA.  */
646   der += ti.length; derlen -= ti.length;
647   
648   if ( parse_tag (&der, &derlen, &ti)
649        || ti.tag != TAG_BIT_STRING || ti.class || ti.cons || ti.ndef)
650     goto bad_asn1;
651   if (ti.length < 1 || *der)
652     goto bad_asn1;  /* The number of unused bits needs to be 0. */
653   der += 1; derlen -= 1;
654
655   /* Parse the BIT string.  */
656   if ( parse_tag (&der, &derlen, &ti)
657        || ti.tag != TAG_SEQUENCE || ti.class || !ti.cons || ti.ndef)
658     goto bad_asn1;
659
660   for (idx=0; idx < n_keyparms; idx++)
661     {
662       if ( parse_tag (&der, &derlen, &ti)
663            || ti.tag != TAG_INTEGER || ti.class || ti.cons || ti.ndef)
664         goto bad_asn1;
665       if (show)
666         {
667           char prefix[2];
668
669           prefix[0] = idx < 2? "ne"[idx] : '?';
670           prefix[1] = 0;
671           showhex (prefix, der, ti.length);
672         }
673       err = gcry_mpi_scan (keyparms+idx, GCRYMPI_FMT_USG, der, ti.length,NULL);
674       if (err)
675         die ("error scanning RSA parameter %d: %s\n", idx, gpg_strerror (err));
676       der += ti.length; derlen -= ti.length;
677     }
678   if (idx != n_keyparms)
679     die ("not enough RSA key parameters\n");
680
681   gcry_free (buffer);
682
683   /* Build the S-expression.  */
684   err = gcry_sexp_build (&s_key, NULL,
685                          "(public-key(rsa(n%m)(e%m)))",
686                          keyparms[0], keyparms[1] );
687   if (err)
688     die ("error building S-expression: %s\n", gpg_strerror (err));
689   
690   for (idx=0; idx < n_keyparms; idx++)
691     gcry_mpi_release (keyparms[idx]);
692   
693   return s_key;
694   
695  bad_asn1:
696   die ("invalid ASN.1 structure in `%s'\n", fname);
697   return NULL; /*NOTREACHED*/
698 }
699
700
701
702 /* Read the file FNAME assuming it is a binary signature result and
703    return an an S-expression suitable for gcry_pk_verify.  */
704 static gcry_sexp_t
705 read_sig_file (const char *fname)
706 {
707   gcry_error_t err;
708   FILE *fp;
709   char *buffer;
710   size_t buflen;
711   gcry_mpi_t tmpmpi;
712   gcry_sexp_t s_sig;
713
714   fp = fopen (fname, "rb");
715   if (!fp)
716     die ("can't open `%s': %s\n", fname, strerror (errno));
717   buffer = read_file (fp, 0, &buflen);
718   if (!buffer)
719     die ("error reading `%s'\n", fname);
720   fclose (fp);
721
722   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, buffer, buflen, NULL);
723   if (!err)
724     err = gcry_sexp_build (&s_sig, NULL,
725                            "(sig-val(rsa(s %m)))", tmpmpi);
726   if (err)
727     die ("error building S-expression: %s\n", gpg_strerror (err));
728   gcry_mpi_release (tmpmpi);
729   gcry_free (buffer);
730
731   return s_sig;
732 }
733
734
735 static void
736 print_buffer (const void *buffer, size_t length)
737 {
738   int writerr = 0;
739
740   if (base64_output)
741     {
742       static const unsigned char bintoasc[64+1] = 
743         ("ABCDEFGHIJKLMNOPQRSTUVWXYZ" 
744          "abcdefghijklmnopqrstuvwxyz" 
745          "0123456789+/"); 
746       const unsigned char *p;
747       unsigned char inbuf[4];
748       char outbuf[4];
749       int idx, quads;
750
751       idx = quads = 0;
752       for (p = buffer; length; p++, length--)
753         {
754           inbuf[idx++] = *p;
755           if (idx > 2)
756             {
757               outbuf[0] = bintoasc[(*inbuf>>2)&077];
758               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
759                                     |((inbuf[1] >> 4)&017))&077];
760               outbuf[2] = bintoasc[(((inbuf[1]<<2)&074)
761                                     |((inbuf[2]>>6)&03))&077];
762               outbuf[3] = bintoasc[inbuf[2]&077];
763               if (fwrite (outbuf, 4, 1, stdout) != 1)
764                 writerr = 1;
765               idx = 0;
766               if (++quads >= (64/4)) 
767                 {
768                   if (fwrite ("\n", 1, 1, stdout) != 1)
769                     writerr = 1;
770                   quads = 0;
771                 }
772             }
773         }
774       if (idx)
775         {
776           outbuf[0] = bintoasc[(*inbuf>>2)&077];
777           if (idx == 1)
778             {
779               outbuf[1] = bintoasc[((*inbuf<<4)&060)&077];
780               outbuf[2] = outbuf[3] = '=';
781             }
782           else 
783             { 
784               outbuf[1] = bintoasc[(((*inbuf<<4)&060)
785                                     |((inbuf[1]>>4)&017))&077];
786               outbuf[2] = bintoasc[((inbuf[1]<<2)&074)&077];
787               outbuf[3] = '=';
788             }
789           if (fwrite (outbuf, 4, 1, stdout) != 1)
790             writerr = 1;
791           quads++;
792         }
793       if (quads && fwrite ("\n", 1, 1, stdout) != 1)
794         writerr = 1;
795     }
796   else if (binary_output)
797     {
798       if (fwrite (buffer, length, 1, stdout) != 1)
799         writerr++;
800     }
801   else
802     {
803       const unsigned char *p = buffer;
804       
805       if (verbose > 1)
806         showhex ("sent line", buffer, length);
807       while (length-- && !ferror (stdout) )
808         printf ("%02X", *p++);
809       if (ferror (stdout))
810         writerr++;
811     }
812   if (!writerr && fflush (stdout) == EOF)
813     writerr++;
814   if (writerr)
815     {
816 #ifndef HAVE_W32_SYSTEM
817       if (loop_mode && errno == EPIPE)
818         loop_mode = 0;
819       else
820 #endif
821         die ("writing output failed: %s\n", strerror (errno));
822     }
823 }
824
825
826 /* Print an MPI on a line.  */
827 static void
828 print_mpi_line (gcry_mpi_t a, int no_lz)
829 {
830   unsigned char *buf, *p;
831   gcry_error_t err;
832   int writerr = 0;
833
834   err = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, a);
835   if (err)
836     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
837
838   p = buf;
839   if (no_lz && p[0] == '0' && p[1] == '0' && p[2])
840     p +=2;
841     
842   printf ("%s\n", p);
843   if (ferror (stdout))
844     writerr++;
845   if (!writerr && fflush (stdout) == EOF)
846     writerr++;
847   if (writerr)
848     die ("writing output failed: %s\n", strerror (errno));
849   gcry_free (buf);
850 }
851
852
853 /* Print some data on hex format on a line.  */
854 static void
855 print_data_line (const void *data, size_t datalen)
856 {
857   const unsigned char *p = data;
858   int writerr = 0;
859       
860   while (data && datalen-- && !ferror (stdout) )
861     printf ("%02X", *p++);
862   putchar ('\n');
863   if (ferror (stdout))
864     writerr++;
865   if (!writerr && fflush (stdout) == EOF)
866     writerr++;
867   if (writerr)
868     die ("writing output failed: %s\n", strerror (errno));
869 }
870
871
872
873
874 static gcry_error_t
875 init_external_rng_test (void **r_context, 
876                     unsigned int flags,
877                     const void *key, size_t keylen,
878                     const void *seed, size_t seedlen,
879                     const void *dt, size_t dtlen)
880 {
881   return gcry_control (PRIV_CTL_INIT_EXTRNG_TEST, 
882                        r_context, flags,
883                        key, keylen,
884                        seed, seedlen,
885                        dt, dtlen);
886 }
887
888 static gcry_error_t
889 run_external_rng_test (void *context, void *buffer, size_t buflen)
890 {
891   return gcry_control (PRIV_CTL_RUN_EXTRNG_TEST, context, buffer, buflen);
892 }
893
894 static void
895 deinit_external_rng_test (void *context)
896 {
897   gcry_control (PRIV_CTL_DEINIT_EXTRNG_TEST, context);
898 }
899
900
901 /* Given an OpenSSL cipher name NAME, return the Libgcrypt algirithm
902    identified and store the libgcrypt mode at R_MODE.  Returns 0 on
903    error.  */
904 static int 
905 map_openssl_cipher_name (const char *name, int *r_mode)
906 {
907   static struct {
908     const char *name;
909     int algo;
910     int mode;
911   } table[] = 
912     {
913       { "bf-cbc",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
914       { "bf",           GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CBC },
915       { "bf-cfb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_CFB },
916       { "bf-ecb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_ECB },
917       { "bf-ofb",       GCRY_CIPHER_BLOWFISH, GCRY_CIPHER_MODE_OFB },
918
919       { "cast-cbc",     GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
920       { "cast",         GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
921       { "cast5-cbc",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CBC },
922       { "cast5-cfb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_CFB },
923       { "cast5-ecb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_ECB },
924       { "cast5-ofb",    GCRY_CIPHER_CAST5, GCRY_CIPHER_MODE_OFB },
925
926       { "des-cbc",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
927       { "des",          GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC },
928       { "des-cfb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CFB },
929       { "des-ofb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_OFB },
930       { "des-ecb",      GCRY_CIPHER_DES, GCRY_CIPHER_MODE_ECB },
931
932       { "des-ede3-cbc", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
933       { "des-ede3",     GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_ECB },
934       { "des3",         GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CBC },
935       { "des-ede3-cfb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_CFB },
936       { "des-ede3-ofb", GCRY_CIPHER_3DES, GCRY_CIPHER_MODE_OFB },
937
938       { "rc4",          GCRY_CIPHER_ARCFOUR, GCRY_CIPHER_MODE_STREAM },
939
940       { "aes-128-cbc",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
941       { "aes-128",      GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CBC },
942       { "aes-128-cfb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CFB },
943       { "aes-128-ecb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB },
944       { "aes-128-ofb",  GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_OFB },
945
946       { "aes-192-cbc",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
947       { "aes-192",      GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CBC },
948       { "aes-192-cfb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_CFB },
949       { "aes-192-ecb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_ECB },
950       { "aes-192-ofb",  GCRY_CIPHER_AES192, GCRY_CIPHER_MODE_OFB },
951       
952       { "aes-256-cbc",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
953       { "aes-256",      GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CBC },
954       { "aes-256-cfb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB },
955       { "aes-256-ecb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_ECB },
956       { "aes-256-ofb",  GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_OFB },
957
958       { NULL, 0 , 0 }
959     };
960   int idx;
961
962   for (idx=0; table[idx].name; idx++)
963     if (!strcmp (name, table[idx].name))
964       {
965         *r_mode = table[idx].mode;
966         return table[idx].algo;
967       }
968   *r_mode = 0;
969   return 0;
970 }
971
972
973 \f
974 /* Run an encrypt or decryption operations.  If DATA is NULL the
975    function reads its input in chunks of size DATALEN from fp and
976    processes it and writes it out until EOF.  */
977 static void
978 run_encrypt_decrypt (int encrypt_mode,
979                      int cipher_algo, int cipher_mode, 
980                      const void *iv_buffer, size_t iv_buflen,
981                      const void *key_buffer, size_t key_buflen,
982                      const void *data, size_t datalen, FILE *fp)
983 {
984   gpg_error_t err;
985   gcry_cipher_hd_t hd;
986   void *outbuf;
987   size_t outbuflen;
988   void *inbuf;
989   size_t inbuflen;
990   size_t blocklen;
991
992   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
993   if (err)
994     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n", 
995          cipher_algo, cipher_mode, gpg_strerror (err));
996
997   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
998   assert (blocklen);
999
1000   gcry_cipher_ctl (hd, PRIV_CTL_DISABLE_WEAK_KEY, NULL, 0);
1001
1002   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
1003   if (err)
1004     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
1005          (unsigned int)key_buflen, gpg_strerror (err));
1006
1007   if (iv_buffer)
1008     {
1009       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
1010       if (err)
1011         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
1012              (unsigned int)iv_buflen, gpg_strerror (err));
1013     }
1014
1015   inbuf = data? NULL : gcry_xmalloc (datalen);
1016   outbuflen = datalen;
1017   outbuf = gcry_xmalloc (outbuflen < blocklen? blocklen:outbuflen);
1018
1019   do
1020     {
1021       if (inbuf)
1022         {
1023           int nread = fread (inbuf, 1, datalen, fp);
1024           if (nread < (int)datalen && ferror (fp))
1025             die ("error reading input\n");
1026           data = inbuf;
1027           inbuflen = nread;
1028         }
1029       else
1030         inbuflen = datalen;
1031
1032       if (encrypt_mode)
1033         err = gcry_cipher_encrypt (hd, outbuf, outbuflen, data, inbuflen);
1034       else
1035         err = gcry_cipher_decrypt (hd, outbuf, outbuflen, data, inbuflen);
1036       if (err)
1037         die ("gcry_cipher_%scrypt failed: %s\n",
1038              encrypt_mode? "en":"de", gpg_strerror (err));
1039       
1040       print_buffer (outbuf, outbuflen);
1041     }
1042   while (inbuf);
1043
1044   gcry_cipher_close (hd);
1045   gcry_free (outbuf);
1046   gcry_free (inbuf);
1047 }
1048
1049
1050 static void
1051 get_current_iv (gcry_cipher_hd_t hd, void *buffer, size_t buflen)
1052 {
1053   unsigned char tmp[17];
1054
1055   if (gcry_cipher_ctl (hd, PRIV_CTL_GET_INPUT_VECTOR, tmp, sizeof tmp))
1056     die ("error getting current input vector\n");
1057   if (buflen > *tmp)
1058     die ("buffer too short to store the current input vector\n");
1059   memcpy (buffer, tmp+1, *tmp);
1060 }
1061
1062 /* Run the inner loop of the CAVS monte carlo test.  */
1063 static void
1064 run_cipher_mct_loop (int encrypt_mode, int cipher_algo, int cipher_mode, 
1065                      const void *iv_buffer, size_t iv_buflen,
1066                      const void *key_buffer, size_t key_buflen,
1067                      const void *data, size_t datalen, int iterations)
1068 {
1069   gpg_error_t err;
1070   gcry_cipher_hd_t hd;
1071   size_t blocklen;
1072   int count;
1073   char input[16];
1074   char output[16];
1075   char last_output[16];
1076   char last_last_output[16];
1077   char last_iv[16]; 
1078
1079
1080   err = gcry_cipher_open (&hd, cipher_algo, cipher_mode, 0);
1081   if (err)
1082     die ("gcry_cipher_open failed for algo %d, mode %d: %s\n", 
1083          cipher_algo, cipher_mode, gpg_strerror (err));
1084
1085   blocklen = gcry_cipher_get_algo_blklen (cipher_algo);
1086   if (!blocklen || blocklen > sizeof output)
1087     die ("invalid block length %d\n", blocklen);
1088
1089
1090   gcry_cipher_ctl (hd, PRIV_CTL_DISABLE_WEAK_KEY, NULL, 0);
1091
1092   err = gcry_cipher_setkey (hd, key_buffer, key_buflen);
1093   if (err)
1094     die ("gcry_cipher_setkey failed with keylen %u: %s\n",
1095          (unsigned int)key_buflen, gpg_strerror (err));
1096
1097   if (iv_buffer)
1098     {
1099       err = gcry_cipher_setiv (hd, iv_buffer, iv_buflen);
1100       if (err)
1101         die ("gcry_cipher_setiv failed with ivlen %u: %s\n",
1102              (unsigned int)iv_buflen, gpg_strerror (err));
1103     }
1104
1105   if (datalen != blocklen)
1106     die ("length of input (%u) does not match block length (%u)\n", 
1107          (unsigned int)datalen, (unsigned int)blocklen);
1108   memcpy (input, data, datalen);
1109   memset (output, 0, sizeof output);
1110   for (count=0; count < iterations; count++)
1111     {
1112       memcpy (last_last_output, last_output, sizeof last_output);
1113       memcpy (last_output, output, sizeof output);
1114
1115       get_current_iv (hd, last_iv, blocklen);
1116
1117       if (encrypt_mode)
1118         err = gcry_cipher_encrypt (hd, output, blocklen, input, blocklen);
1119       else
1120         err = gcry_cipher_decrypt (hd, output, blocklen, input, blocklen);
1121       if (err)
1122         die ("gcry_cipher_%scrypt failed: %s\n",
1123              encrypt_mode? "en":"de", gpg_strerror (err));
1124
1125   
1126       if (encrypt_mode && (cipher_mode == GCRY_CIPHER_MODE_CFB
1127                            || cipher_mode == GCRY_CIPHER_MODE_CBC))
1128         memcpy (input, last_iv, blocklen);
1129       else if (cipher_mode == GCRY_CIPHER_MODE_OFB)
1130         memcpy (input, last_iv, blocklen);
1131       else if (!encrypt_mode && cipher_mode == GCRY_CIPHER_MODE_CFB)
1132         {
1133           /* Reconstruct the output vector.  */
1134           int i;
1135           for (i=0; i < blocklen; i++)
1136             input[i] ^= output[i];
1137         }
1138       else
1139         memcpy (input, output, blocklen);
1140     }
1141
1142   print_buffer (output, blocklen);
1143   putchar ('\n');
1144   print_buffer (last_output, blocklen);
1145   putchar ('\n');
1146   print_buffer (last_last_output, blocklen);
1147   putchar ('\n');
1148   get_current_iv (hd, last_iv, blocklen);
1149   print_buffer (last_iv, blocklen); /* Last output vector.  */
1150   putchar ('\n');
1151   print_buffer (input, blocklen);   /* Next input text. */
1152   putchar ('\n');
1153   if (verbose > 1)
1154     showhex ("sent line", "", 0);
1155   putchar ('\n');
1156   fflush (stdout);
1157
1158   gcry_cipher_close (hd);
1159 }
1160
1161
1162 \f
1163 /* Run a digest operation.  */
1164 static void
1165 run_digest (int digest_algo,  const void *data, size_t datalen)
1166 {
1167   gpg_error_t err;
1168   gcry_md_hd_t hd;
1169   const unsigned char *digest;
1170   unsigned int digestlen;
1171
1172   err = gcry_md_open (&hd, digest_algo, 0);
1173   if (err)
1174     die ("gcry_md_open failed for algo %d: %s\n", 
1175          digest_algo,  gpg_strerror (err));
1176
1177   gcry_md_write (hd, data, datalen);
1178   digest = gcry_md_read (hd, digest_algo);
1179   digestlen = gcry_md_get_algo_dlen (digest_algo);
1180   print_buffer (digest, digestlen);
1181   gcry_md_close (hd);
1182 }
1183
1184 \f
1185 /* Run a HMAC operation.  */
1186 static void
1187 run_hmac (int digest_algo, const void *key, size_t keylen, 
1188           const void *data, size_t datalen)
1189 {
1190   gpg_error_t err;
1191   gcry_md_hd_t hd;
1192   const unsigned char *digest;
1193   unsigned int digestlen;
1194
1195   err = gcry_md_open (&hd, digest_algo, GCRY_MD_FLAG_HMAC);
1196   if (err)
1197     die ("gcry_md_open failed for HMAC algo %d: %s\n", 
1198          digest_algo,  gpg_strerror (err));
1199
1200   gcry_md_setkey (hd, key, keylen);
1201   if (err)
1202     die ("gcry_md_setkey failed for HMAC algo %d: %s\n", 
1203          digest_algo,  gpg_strerror (err));
1204
1205   gcry_md_write (hd, data, datalen);
1206   digest = gcry_md_read (hd, digest_algo);
1207   digestlen = gcry_md_get_algo_dlen (digest_algo);
1208   print_buffer (digest, digestlen);
1209   gcry_md_close (hd);
1210 }
1211
1212 \f
1213 static size_t
1214 compute_tag_length (size_t n)
1215 {     
1216   int needed = 0;
1217
1218   if (n < 128)
1219     needed += 2; /* Tag and one length byte.  */
1220   else if (n < 256)
1221     needed += 3; /* Tag, number of length bytes, 1 length byte.  */
1222   else if (n < 65536)
1223     needed += 4; /* Tag, number of length bytes, 2 length bytes.  */
1224   else
1225     die ("DER object too long to encode\n");
1226
1227   return needed;
1228 }
1229
1230 static unsigned char *
1231 store_tag_length (unsigned char *p, int tag, size_t n)
1232 {     
1233   if (tag == TAG_SEQUENCE)
1234     tag |= 0x20; /* constructed */
1235
1236   *p++ = tag;
1237   if (n < 128)
1238     *p++ = n;
1239   else if (n < 256)
1240     {
1241       *p++ = 0x81;
1242       *p++ = n;
1243     }
1244   else if (n < 65536)
1245     {
1246       *p++ = 0x82;
1247       *p++ = n >> 8;
1248       *p++ = n;
1249     }
1250
1251   return p;
1252 }
1253
1254
1255 /* Generate an RSA key of size KEYSIZE using the public exponent
1256    PUBEXP and print it to stdout in the OpenSSL format.  The format
1257    is:
1258
1259        SEQUENCE {
1260          INTEGER (0)  -- Unknown constant. 
1261          INTEGER      -- n
1262          INTEGER      -- e
1263          INTEGER      -- d
1264          INTEGER      -- p     
1265          INTEGER      -- q      (with p < q)
1266          INTEGER      -- dmp1 = d mod (p-1)
1267          INTEGER      -- dmq1 = d mod (q-1)
1268          INTEGER      -- u    = p^{-1} mod q
1269        }
1270
1271 */
1272 static void
1273 run_rsa_gen (int keysize, int pubexp)
1274 {
1275   gpg_error_t err;
1276   gcry_sexp_t keyspec, key, l1;
1277   const char keyelems[] = "nedpq..u";
1278   gcry_mpi_t keyparms[8];
1279   size_t     keyparmslen[8];
1280   int idx;
1281   size_t derlen, needed, n;
1282   unsigned char *derbuf, *der;
1283
1284   err = gcry_sexp_build (&keyspec, NULL, 
1285                          "(genkey (rsa (nbits %d)(rsa-use-e %d)))",
1286                          keysize, pubexp);
1287   if (err)
1288     die ("gcry_sexp_build failed for RSA key generation: %s\n",
1289          gpg_strerror (err));
1290
1291   err = gcry_pk_genkey (&key, keyspec);
1292   if (err)
1293     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1294   
1295   gcry_sexp_release (keyspec);
1296
1297   l1 = gcry_sexp_find_token (key, "private-key", 0);
1298   if (!l1)
1299     die ("private key not found in genkey result\n");
1300   gcry_sexp_release (key);
1301   key = l1;
1302
1303   l1 = gcry_sexp_find_token (key, "rsa", 0);
1304   if (!l1)
1305     die ("returned private key not formed as expected\n");
1306   gcry_sexp_release (key);
1307   key = l1;
1308
1309   /* Extract the parameters from the S-expression and store them in a
1310      well defined order in KEYPARMS.  */
1311   for (idx=0; idx < DIM(keyparms); idx++) 
1312     {
1313       if (keyelems[idx] == '.')
1314         {
1315           keyparms[idx] = gcry_mpi_new (0);
1316           continue;
1317         }
1318       l1 = gcry_sexp_find_token (key, keyelems+idx, 1);
1319       if (!l1)
1320         die ("no %c parameter in returned private key\n", keyelems[idx]);
1321       keyparms[idx] = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
1322       if (!keyparms[idx])
1323         die ("no value for %c parameter in returned private key\n",
1324              keyelems[idx]);
1325       gcry_sexp_release (l1);
1326     }
1327
1328   gcry_sexp_release (key);
1329
1330   /* Check that p < q; if not swap p and q and recompute u.  */ 
1331   if (gcry_mpi_cmp (keyparms[3], keyparms[4]) > 0)
1332     {
1333       gcry_mpi_swap (keyparms[3], keyparms[4]);
1334       gcry_mpi_invm (keyparms[7], keyparms[3], keyparms[4]);
1335     }
1336
1337   /* Compute the additional parameters.  */
1338   gcry_mpi_sub_ui (keyparms[5], keyparms[3], 1);
1339   gcry_mpi_mod (keyparms[5], keyparms[2], keyparms[5]);
1340   gcry_mpi_sub_ui (keyparms[6], keyparms[4], 1);
1341   gcry_mpi_mod (keyparms[6], keyparms[2], keyparms[6]);
1342
1343   /* Compute the length of the DER encoding.  */
1344   needed = compute_tag_length (1) + 1;  
1345   for (idx=0; idx < DIM(keyparms); idx++) 
1346     {
1347       err = gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &n, keyparms[idx]);
1348       if (err)
1349         die ("error formatting parameter: %s\n", gpg_strerror (err));
1350       keyparmslen[idx] = n;
1351       needed += compute_tag_length (n) + n;
1352     }
1353   
1354   /* Store the key parameters. */
1355   derlen = compute_tag_length (needed) + needed;
1356   der = derbuf = gcry_xmalloc (derlen);
1357
1358   der = store_tag_length (der, TAG_SEQUENCE, needed);
1359   der = store_tag_length (der, TAG_INTEGER, 1);
1360   *der++ = 0;
1361   for (idx=0; idx < DIM(keyparms); idx++) 
1362     {
1363       der = store_tag_length (der, TAG_INTEGER, keyparmslen[idx]);
1364       err = gcry_mpi_print (GCRYMPI_FMT_STD, der, 
1365                            keyparmslen[idx], NULL, keyparms[idx]);
1366       if (err)
1367         die ("error formatting parameter: %s\n", gpg_strerror (err));
1368       der += keyparmslen[idx];
1369     }
1370
1371   /* Print the stuff.  */
1372   for (idx=0; idx < DIM(keyparms); idx++) 
1373     gcry_mpi_release (keyparms[idx]);
1374
1375   assert (der - derbuf == derlen);
1376
1377   if (base64_output)
1378     puts ("-----BEGIN RSA PRIVATE KEY-----");
1379   print_buffer (derbuf, derlen);
1380   if (base64_output)
1381     puts ("-----END RSA PRIVATE KEY-----");
1382
1383   gcry_free (derbuf);
1384 }
1385
1386
1387 \f
1388 /* Sign DATA of length DATALEN using the key taken from the PEM
1389    encoded KEYFILE and the hash algorithm HASHALGO.  */
1390 static void
1391 run_rsa_sign (const void *data, size_t datalen,
1392               int hashalgo, int pkcs1, const char *keyfile)
1393
1394 {
1395   gpg_error_t err;
1396   gcry_sexp_t s_data, s_key, s_sig, s_tmp;
1397   gcry_mpi_t sig_mpi = NULL;
1398   unsigned char *outbuf;
1399   size_t outlen;
1400   
1401 /*   showhex ("D", data, datalen); */
1402   if (pkcs1)
1403     {
1404       unsigned char hash[64];
1405       unsigned int hashsize;
1406
1407       hashsize = gcry_md_get_algo_dlen (hashalgo);
1408       if (!hashsize || hashsize > sizeof hash)
1409         die ("digest too long for buffer or unknown hash algorithm\n");
1410       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1411       err = gcry_sexp_build (&s_data, NULL,
1412                              "(data (flags pkcs1)(hash %s %b))",
1413                              gcry_md_algo_name (hashalgo),
1414                              (int)hashsize, hash);
1415     }
1416   else
1417     {
1418       gcry_mpi_t tmp;
1419
1420       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1421       if (!err)
1422         {
1423           err = gcry_sexp_build (&s_data, NULL,
1424                                  "(data (flags raw)(value %m))", tmp);
1425           gcry_mpi_release (tmp);
1426         }
1427     }
1428   if (err)
1429     die ("gcry_sexp_build failed for RSA data input: %s\n",
1430          gpg_strerror (err));
1431
1432   s_key = read_private_key_file (keyfile, 0);
1433
1434   err = gcry_pk_sign (&s_sig, s_data, s_key);
1435   if (err)
1436     {
1437       gcry_sexp_release (read_private_key_file (keyfile, 1));
1438       die ("gcry_pk_signed failed (datalen=%d,keyfile=%s): %s\n",
1439            (int)datalen, keyfile, gpg_strerror (err));
1440     }
1441   gcry_sexp_release (s_key);
1442   gcry_sexp_release (s_data);
1443
1444   s_tmp = gcry_sexp_find_token (s_sig, "sig-val", 0);
1445   if (s_tmp)
1446     {
1447       gcry_sexp_release (s_sig);
1448       s_sig = s_tmp;
1449       s_tmp = gcry_sexp_find_token (s_sig, "rsa", 0);
1450       if (s_tmp)
1451         {
1452           gcry_sexp_release (s_sig);
1453           s_sig = s_tmp;
1454           s_tmp = gcry_sexp_find_token (s_sig, "s", 0);
1455           if (s_tmp)
1456             {
1457               gcry_sexp_release (s_sig);
1458               s_sig = s_tmp;
1459               sig_mpi = gcry_sexp_nth_mpi (s_sig, 1, GCRYMPI_FMT_USG);
1460             }
1461         }
1462     }
1463   gcry_sexp_release (s_sig);
1464               
1465   if (!sig_mpi)
1466     die ("no value in returned S-expression\n");
1467   err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &outbuf, &outlen, sig_mpi);
1468   if (err)
1469     die ("gcry_mpi_aprint failed: %s\n", gpg_strerror (err));
1470   gcry_mpi_release (sig_mpi);
1471
1472   print_buffer (outbuf, outlen);
1473   gcry_free (outbuf);
1474 }
1475
1476
1477 \f
1478 /* Verify DATA of length DATALEN using the public key taken from the
1479    PEM encoded KEYFILE and the hash algorithm HASHALGO against the
1480    binary signature in SIGFILE.  */
1481 static void
1482 run_rsa_verify (const void *data, size_t datalen, int hashalgo, int pkcs1,
1483                 const char *keyfile, const char *sigfile)
1484
1485 {
1486   gpg_error_t err;
1487   gcry_sexp_t s_data, s_key, s_sig;
1488   
1489   if (pkcs1)
1490     {
1491       unsigned char hash[64];
1492       unsigned int hashsize;
1493
1494       hashsize = gcry_md_get_algo_dlen (hashalgo);
1495       if (!hashsize || hashsize > sizeof hash)
1496         die ("digest too long for buffer or unknown hash algorithm\n");
1497       gcry_md_hash_buffer (hashalgo, hash, data, datalen);
1498       err = gcry_sexp_build (&s_data, NULL,
1499                              "(data (flags pkcs1)(hash %s %b))",
1500                              gcry_md_algo_name (hashalgo),
1501                              (int)hashsize, hash);
1502     }
1503   else
1504     {
1505       gcry_mpi_t tmp;
1506
1507       err = gcry_mpi_scan (&tmp, GCRYMPI_FMT_USG, data, datalen,NULL);
1508       if (!err)
1509         {
1510           err = gcry_sexp_build (&s_data, NULL,
1511                                  "(data (flags raw)(value %m))", tmp);
1512           gcry_mpi_release (tmp);
1513         }
1514     }
1515   if (err)
1516     die ("gcry_sexp_build failed for RSA data input: %s\n",
1517          gpg_strerror (err));
1518
1519   s_key = read_public_key_file (keyfile, 0);
1520
1521   s_sig = read_sig_file (sigfile);
1522
1523   err = gcry_pk_verify (s_sig, s_data, s_key);
1524   if (!err)
1525     puts ("GOOD signature");
1526   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
1527     puts ("BAD signature");
1528   else
1529     printf ("ERROR (%s)\n", gpg_strerror (err));
1530
1531   gcry_sexp_release (s_sig);
1532   gcry_sexp_release (s_key);
1533   gcry_sexp_release (s_data);
1534 }
1535
1536
1537 \f
1538 /* Generate DSA donmain parameters for a modulus size of KEYSIZE.  The
1539    result is printed to stdout with one parameter per line in hex
1540    format and in this order: p, q, g, seed, counter, h.  */
1541 static void
1542 run_dsa_pqg_gen (int keysize)
1543 {
1544   gpg_error_t err;
1545   gcry_sexp_t keyspec, key, l1, l2;
1546   gcry_mpi_t mpi;
1547   int idx;
1548   const void *data;
1549   size_t datalen;
1550   char *string;
1551
1552   /* Note that we create a complete key but don't return the x and y
1553      values.  */
1554   err = gcry_sexp_build (&keyspec, NULL, 
1555                          "(genkey (dsa (nbits %d)(use-fips186-2)))",
1556                          keysize);
1557   if (err)
1558     die ("gcry_sexp_build failed for DSA domain parameter generation: %s\n",
1559          gpg_strerror (err));
1560
1561   err = gcry_pk_genkey (&key, keyspec);
1562   if (err)
1563     die ("gcry_pk_genkey failed for RSA: %s\n", gpg_strerror (err));
1564   
1565   gcry_sexp_release (keyspec);
1566
1567   l1 = gcry_sexp_find_token (key, "private-key", 0);
1568   if (!l1)
1569     die ("private key not found in genkey result\n");
1570
1571   l2 = gcry_sexp_find_token (l1, "dsa", 0);
1572   if (!l2)
1573     die ("returned private key not formed as expected\n");
1574   gcry_sexp_release (l1);
1575   l1 = l2;
1576
1577   /* Extract the parameters from the S-expression and print them to stdout.  */
1578   for (idx=0; "pqg"[idx]; idx++) 
1579     {
1580       l2 = gcry_sexp_find_token (l1, "pqg"+idx, 1);
1581       if (!l2)
1582         die ("no %c parameter in returned private key\n", "pqg"[idx]);
1583       mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1584       if (!mpi)
1585         die ("no value for %c parameter in returned private key\n","pqg"[idx]);
1586       gcry_sexp_release (l2);
1587       print_mpi_line (mpi, 1);
1588       gcry_mpi_release (mpi);
1589     }
1590   gcry_sexp_release (l1);
1591
1592   /* Extract the seed values.  */
1593   l1 = gcry_sexp_find_token (key, "misc-key-info", 0);
1594   if (!l1)
1595     die ("misc-key-info not found in genkey result\n");
1596
1597   l2 = gcry_sexp_find_token (l1, "seed-values", 0);
1598   if (!l2)
1599     die ("no seed-values in returned private key\n");
1600   gcry_sexp_release (l1);
1601   l1 = l2;
1602
1603   l2 = gcry_sexp_find_token (l1, "seed", 0);
1604   if (!l2)
1605     die ("no seed value in returned private key\n");
1606   data = gcry_sexp_nth_data (l2, 1, &datalen);
1607   if (!data)
1608     die ("no seed value in returned private key\n");
1609   print_data_line (data, datalen);
1610   gcry_sexp_release (l2);
1611
1612   l2 = gcry_sexp_find_token (l1, "counter", 0);
1613   if (!l2)
1614     die ("no counter value in returned private key\n");
1615   string = gcry_sexp_nth_string (l2, 1);
1616   if (!string)
1617     die ("no counter value in returned private key\n");
1618   printf ("%lX\n", strtoul (string, NULL, 10));
1619   gcry_free (string);
1620   gcry_sexp_release (l2);
1621
1622   l2 = gcry_sexp_find_token (l1, "h", 0);
1623   if (!l2)
1624     die ("no n value in returned private key\n");
1625   mpi = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
1626   if (!mpi)
1627     die ("no h value in returned private key\n");
1628   print_mpi_line (mpi, 1);
1629   gcry_mpi_release (mpi);
1630   gcry_sexp_release (l2);
1631
1632   gcry_sexp_release (l1);
1633   gcry_sexp_release (key);
1634 }
1635
1636
1637 \f
1638 static void
1639 usage (int show_help)
1640 {
1641   if (!show_help)
1642     {
1643       fputs ("usage: " PGM 
1644              " [OPTION] [FILE] (try --help for more information)\n", stderr);
1645       exit (2);
1646     }
1647   fputs
1648     ("Usage: " PGM " [OPTIONS] MODE [FILE]\n"
1649      "Run a crypto operation using hex encoded input and output.\n"
1650      "MODE:\n"
1651      "  encrypt, decrypt, digest, random, hmac-sha, rsa-{gen,sign,verify},\n"
1652      "  dsa-pqg-gen\n"
1653      "OPTIONS:\n"
1654      "  --verbose        Print additional information\n"
1655      "  --binary         Input and output is in binary form\n"
1656      "  --no-fips        Do not force FIPS mode\n"
1657      "  --key KEY        Use the hex encoded KEY\n"
1658      "  --iv IV          Use the hex encoded IV\n"
1659      "  --dt DT          Use the hex encoded DT for the RNG\n"
1660      "  --algo NAME      Use algorithm NAME\n"
1661      "  --keysize N      Use a keysize of N bits\n"
1662      "  --signature NAME Take signature from file NAME\n"
1663      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
1664      "  --pkcs1          Use PKCS#1 encoding\n"
1665      "  --mct-server     Run a monte carlo test server\n"
1666      "  --loop           Enable random loop mode\n"
1667      "  --progress       Print pogress indicators\n"
1668      "  --help           Print this text\n"
1669      "With no FILE, or when FILE is -, read standard input.\n"
1670      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
1671   exit (0);
1672 }
1673
1674 int
1675 main (int argc, char **argv)
1676 {
1677   int last_argc = -1;
1678   gpg_error_t err;
1679   int no_fips = 0;
1680   int progress = 0;
1681   int use_pkcs1 = 0;
1682   const char *mode_string;
1683   const char *key_string = NULL;
1684   const char *iv_string = NULL;
1685   const char *dt_string = NULL;
1686   const char *algo_string = NULL;
1687   const char *keysize_string = NULL;
1688   const char *signature_string = NULL;
1689   FILE *input;
1690   void *data;
1691   size_t datalen;
1692   size_t chunksize = 0;
1693   int mct_server = 0;
1694
1695
1696   if (argc)
1697     { argc--; argv++; }
1698
1699   while (argc && last_argc != argc )
1700     {
1701       last_argc = argc;
1702       if (!strcmp (*argv, "--"))
1703         {
1704           argc--; argv++;
1705           break;
1706         }
1707       else if (!strcmp (*argv, "--help"))
1708         {
1709           usage (1);
1710         }
1711       else if (!strcmp (*argv, "--version"))
1712         {
1713           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
1714           exit (0);
1715         }
1716       else if (!strcmp (*argv, "--verbose"))
1717         {
1718           verbose++;
1719           argc--; argv++;
1720         }
1721       else if (!strcmp (*argv, "--binary"))
1722         {
1723           binary_input = binary_output = 1;
1724           argc--; argv++;
1725         }
1726       else if (!strcmp (*argv, "--no-fips"))
1727         {
1728           no_fips++;
1729           argc--; argv++;
1730         }
1731       else if (!strcmp (*argv, "--loop"))
1732         {
1733           loop_mode = 1;
1734           argc--; argv++;
1735         }
1736       else if (!strcmp (*argv, "--progress"))
1737         {
1738           progress = 1;
1739           argc--; argv++;
1740         }
1741       else if (!strcmp (*argv, "--key"))
1742         {
1743           argc--; argv++;
1744           if (!argc)
1745             usage (0);
1746           key_string = *argv;
1747           argc--; argv++;
1748         }
1749       else if (!strcmp (*argv, "--iv"))
1750         {
1751           argc--; argv++;
1752           if (!argc)
1753             usage (0);
1754           iv_string = *argv;
1755           argc--; argv++;
1756         }
1757       else if (!strcmp (*argv, "--dt"))
1758         {
1759           argc--; argv++;
1760           if (!argc)
1761             usage (0);
1762           dt_string = *argv;
1763           argc--; argv++;
1764         }
1765       else if (!strcmp (*argv, "--algo"))
1766         {
1767           argc--; argv++;
1768           if (!argc)
1769             usage (0);
1770           algo_string = *argv;
1771           argc--; argv++;
1772         }
1773       else if (!strcmp (*argv, "--keysize"))
1774         {
1775           argc--; argv++;
1776           if (!argc)
1777             usage (0);
1778           keysize_string = *argv;
1779           argc--; argv++;
1780         }
1781       else if (!strcmp (*argv, "--signature"))
1782         {
1783           argc--; argv++;
1784           if (!argc)
1785             usage (0);
1786           signature_string = *argv;
1787           argc--; argv++;
1788         }
1789       else if (!strcmp (*argv, "--chunk"))
1790         {
1791           argc--; argv++;
1792           if (!argc)
1793             usage (0);
1794           chunksize = atoi (*argv);
1795           binary_input = binary_output = 1;
1796           argc--; argv++;
1797         }
1798       else if (!strcmp (*argv, "--pkcs1"))
1799         {
1800           use_pkcs1 = 1;
1801           argc--; argv++;
1802         }
1803       else if (!strcmp (*argv, "--mct-server"))
1804         {
1805           mct_server = 1;
1806           argc--; argv++;
1807         }
1808     }          
1809
1810   if (!argc || argc > 2)
1811     usage (0);
1812   mode_string = *argv;
1813   if (argc == 2 && strcmp (argv[1], "-"))
1814     {
1815       input = fopen (argv[1], binary_input? "rb":"r");
1816       if (!input)
1817         die ("can't open `%s': %s\n", argv[1], strerror (errno));
1818     }
1819   else
1820     input = stdin;
1821
1822 #ifndef HAVE_W32_SYSTEM
1823   if (loop_mode)
1824     signal (SIGPIPE, SIG_IGN);
1825 #endif
1826
1827   if (verbose)
1828     fprintf (stderr, PGM ": started (mode=%s)\n", mode_string);
1829
1830   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
1831   if (!no_fips)
1832     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
1833   if (!gcry_check_version ("1.4.3"))
1834     die ("Libgcrypt is not sufficient enough\n");
1835   if (verbose)
1836     fprintf (stderr, PGM ": using Libgcrypt %s\n", gcry_check_version (NULL));
1837   if (no_fips)
1838     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1839   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1840
1841   /* Most operations need some input data.  */
1842   if (!chunksize
1843       && !mct_server
1844       && strcmp (mode_string, "random")
1845       && strcmp (mode_string, "rsa-gen")
1846       && strcmp (mode_string, "dsa-pqg-gen") )
1847     {
1848       data = read_file (input, !binary_input, &datalen);
1849       if (!data)
1850         die ("error reading%s input\n", binary_input?"":" and decoding");
1851       if (verbose)
1852         fprintf (stderr, PGM ": %u bytes of input data\n", 
1853                  (unsigned int)datalen);
1854     }
1855   else
1856     {
1857       data = NULL;
1858       datalen = 0;
1859     }
1860
1861
1862   if (!strcmp (mode_string, "encrypt") || !strcmp (mode_string, "decrypt"))
1863     {
1864       int cipher_algo, cipher_mode;
1865       void  *iv_buffer = NULL;
1866       void *key_buffer = NULL;
1867       size_t iv_buflen,  key_buflen;
1868
1869       if (!algo_string)
1870         die ("option --algo is required in this mode\n");
1871       cipher_algo = map_openssl_cipher_name (algo_string, &cipher_mode);
1872       if (!cipher_algo)
1873         die ("cipher algorithm `%s' is not supported\n", algo_string);
1874       if (mct_server)
1875         {
1876           int iterations;
1877
1878           for (;;)
1879             {
1880               gcry_free (key_buffer); key_buffer = NULL;
1881               gcry_free (iv_buffer); iv_buffer = NULL;
1882               gcry_free (data); data = NULL;
1883               if (!(key_buffer = read_textline (input)))
1884                 {
1885                   if (feof (input))
1886                     break;
1887                   die ("no version info in input\n");
1888                 }
1889               if (atoi (key_buffer) != 1)
1890                 die ("unsupported input version %s\n", key_buffer);
1891               gcry_free (key_buffer);
1892               if (!(key_buffer = read_textline (input)))
1893                 die ("no iteration count in input\n");
1894               iterations = atoi (key_buffer);
1895               gcry_free (key_buffer);
1896               if (!(key_buffer = read_hexline (input, &key_buflen)))
1897                 die ("no key in input\n");
1898               if (!(iv_buffer = read_hexline (input, &iv_buflen)))
1899                 die ("no IV in input\n");
1900               if (!(data = read_hexline (input, &datalen)))
1901                 die ("no data in input\n");
1902               skip_to_empty_line (input);
1903               
1904               run_cipher_mct_loop ((*mode_string == 'e'),
1905                                    cipher_algo, cipher_mode,
1906                                    iv_buffer, iv_buflen,
1907                                    key_buffer, key_buflen,
1908                                    data, datalen, iterations);
1909             }
1910         }
1911       else
1912         {
1913           if (cipher_mode != GCRY_CIPHER_MODE_ECB)
1914             {
1915               if (!iv_string)
1916                 die ("option --iv is required in this mode\n");
1917               iv_buffer = hex2buffer (iv_string, &iv_buflen);
1918               if (!iv_buffer)
1919                 die ("invalid value for IV\n");
1920             }
1921           else
1922             {
1923               iv_buffer = NULL;
1924               iv_buflen = 0;
1925             }
1926           if (!key_string)
1927             die ("option --key is required in this mode\n");
1928           key_buffer = hex2buffer (key_string, &key_buflen);
1929           if (!key_buffer)
1930             die ("invalid value for KEY\n");
1931
1932           run_encrypt_decrypt ((*mode_string == 'e'),
1933                                cipher_algo, cipher_mode,
1934                                iv_buffer, iv_buflen,
1935                                key_buffer, key_buflen,
1936                                data, data? datalen:chunksize, input);
1937         }
1938       gcry_free (key_buffer);
1939       gcry_free (iv_buffer);
1940     }
1941   else if (!strcmp (mode_string, "digest"))
1942     {
1943       int algo;
1944
1945       if (!algo_string)
1946         die ("option --algo is required in this mode\n");
1947       algo = gcry_md_map_name (algo_string);
1948       if (!algo)
1949         die ("digest algorithm `%s' is not supported\n", algo_string);
1950       if (!data)
1951         die ("no data available (do not use --chunk)\n");
1952
1953       run_digest (algo, data, datalen);
1954     }
1955   else if (!strcmp (mode_string, "random"))
1956     {
1957       void *context;
1958       unsigned char key[16];
1959       unsigned char seed[16];
1960       unsigned char dt[16];
1961       unsigned char buffer[16];
1962       size_t count = 0;
1963
1964       if (hex2bin (key_string, key, 16) < 0 )
1965         die ("value for --key are not 32 hex digits\n");
1966       if (hex2bin (iv_string, seed, 16) < 0 )
1967         die ("value for --iv are not 32 hex digits\n");
1968       if (hex2bin (dt_string, dt, 16) < 0 )
1969         die ("value for --dt are not 32 hex digits\n");
1970
1971       /* The flag value 1 disables the dup check, so that the RNG
1972          returns all generated data.  */
1973       err = init_external_rng_test (&context, 1, key, 16, seed, 16, dt, 16);
1974       if (err)
1975         die ("init external RNG test failed: %s\n", gpg_strerror (err));
1976
1977       do 
1978         {
1979           err = run_external_rng_test (context, buffer, sizeof buffer);
1980           if (err)
1981             die ("running external RNG test failed: %s\n", gpg_strerror (err));
1982           print_buffer (buffer, sizeof buffer);
1983           if (progress)
1984             {
1985               if (!(++count % 1000))
1986                 fprintf (stderr, PGM ": %lu random bytes so far\n", 
1987                          (unsigned long int)count * sizeof buffer);
1988             }
1989         }
1990       while (loop_mode);
1991       
1992       if (progress)
1993         fprintf (stderr, PGM ": %lu random bytes\n",
1994                          (unsigned long int)count * sizeof buffer);
1995
1996       deinit_external_rng_test (context);
1997     }
1998   else if (!strcmp (mode_string, "hmac-sha"))
1999     {
2000       int algo;
2001       void  *key_buffer;
2002       size_t key_buflen;
2003
2004       if (!data)
2005         die ("no data available (do not use --chunk)\n");
2006       if (!algo_string)
2007         die ("option --algo is required in this mode\n");
2008       switch (atoi (algo_string))
2009         {
2010         case 1:   algo = GCRY_MD_SHA1; break;
2011         case 224: algo = GCRY_MD_SHA224; break;
2012         case 256: algo = GCRY_MD_SHA256; break;
2013         case 384: algo = GCRY_MD_SHA384; break;
2014         case 512: algo = GCRY_MD_SHA512; break;
2015         default:  algo = 0; break;
2016         }
2017       if (!algo)
2018         die ("no digest algorithm found for hmac type `%s'\n", algo_string);
2019       if (!key_string)
2020         die ("option --key is required in this mode\n");
2021       key_buffer = hex2buffer (key_string, &key_buflen);
2022       if (!key_buffer)
2023         die ("invalid value for KEY\n");
2024
2025       run_hmac (algo, key_buffer, key_buflen, data, datalen);
2026
2027       gcry_free (key_buffer);
2028     }
2029   else if (!strcmp (mode_string, "rsa-gen"))
2030     {
2031       int keysize;
2032       
2033       if (!binary_output)
2034         base64_output = 1;
2035
2036       keysize = keysize_string? atoi (keysize_string) : 0;
2037       if (keysize < 128 || keysize > 16384)
2038         die ("invalid keysize specified; needs to be 128 .. 16384\n");
2039       run_rsa_gen (keysize, 65537);
2040     }
2041   else if (!strcmp (mode_string, "rsa-sign"))
2042     {
2043       int algo;
2044
2045       if (!key_string)
2046         die ("option --key is required in this mode\n");
2047       if (access (key_string, R_OK))
2048         die ("option --key needs to specify an existing keyfile\n");
2049       if (!algo_string)
2050         die ("option --algo is required in this mode\n");
2051       algo = gcry_md_map_name (algo_string);
2052       if (!algo)
2053         die ("digest algorithm `%s' is not supported\n", algo_string);
2054       if (!data)
2055         die ("no data available (do not use --chunk)\n");
2056
2057       run_rsa_sign (data, datalen, algo, use_pkcs1, key_string);
2058
2059     }
2060   else if (!strcmp (mode_string, "rsa-verify"))
2061     {
2062       int algo;
2063
2064       if (!key_string)
2065         die ("option --key is required in this mode\n");
2066       if (access (key_string, R_OK))
2067         die ("option --key needs to specify an existing keyfile\n");
2068       if (!algo_string)
2069         die ("option --algo is required in this mode\n");
2070       algo = gcry_md_map_name (algo_string);
2071       if (!algo)
2072         die ("digest algorithm `%s' is not supported\n", algo_string);
2073       if (!data)
2074         die ("no data available (do not use --chunk)\n");
2075       if (!signature_string)
2076         die ("option --signature is required in this mode\n");
2077       if (access (signature_string, R_OK))
2078         die ("option --signature needs to specify an existing file\n");
2079
2080       run_rsa_verify (data, datalen, algo, use_pkcs1, key_string,
2081                       signature_string);
2082
2083     }
2084   else if (!strcmp (mode_string, "dsa-pqg-gen"))
2085     {
2086       int keysize;
2087       
2088       keysize = keysize_string? atoi (keysize_string) : 0;
2089       if (keysize < 1024 || keysize > 3072)
2090         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2091       run_dsa_pqg_gen (keysize);
2092     }
2093   else
2094     usage (0);
2095
2096   gcry_free (data);
2097
2098   /* Because Libgcrypt does not enforce FIPS mode in all cases we let
2099      the process die if Libgcrypt is not anymore in FIPS mode after
2100      the actual operation.  */
2101   if (!no_fips && !gcry_fips_mode_active ())
2102     die ("FIPS mode is not anymore active\n");
2103
2104   if (verbose)
2105     fputs (PGM ": ready\n", stderr);
2106
2107   return 0;
2108 }
2109