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