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