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