Fix last change.
[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   gcry_mpi_t tmpmpi;
1920
1921   gcry_md_hash_buffer (GCRY_MD_SHA1, hash, data, datalen);
1922   /* Note that we can't simply use %b with HASH to build the
1923      S-expression, because that might yield a negative value.  */
1924   err = gcry_mpi_scan (&tmpmpi, GCRYMPI_FMT_USG, hash, 20, NULL);
1925   if (!err)
1926     {
1927       err = gcry_sexp_build (&s_data, NULL,
1928                              "(data (flags raw)(value %m))", tmpmpi);
1929       gcry_mpi_release (tmpmpi);
1930     }
1931   if (err)
1932     die ("gcry_sexp_build failed for DSA data input: %s\n",
1933          gpg_strerror (err));
1934
1935   s_key = read_sexp_from_file (keyfile);
1936   s_sig = read_sexp_from_file (sigfile);
1937
1938   err = gcry_pk_verify (s_sig, s_data, s_key);
1939   if (!err)
1940     puts ("GOOD signature");
1941   else if (gpg_err_code (err) == GPG_ERR_BAD_SIGNATURE)
1942     puts ("BAD signature");
1943   else
1944     printf ("ERROR (%s)\n", gpg_strerror (err));
1945
1946   gcry_sexp_release (s_sig);
1947   gcry_sexp_release (s_key);
1948   gcry_sexp_release (s_data);
1949 }
1950
1951
1952
1953 \f
1954 static void
1955 usage (int show_help)
1956 {
1957   if (!show_help)
1958     {
1959       fputs ("usage: " PGM 
1960              " [OPTION] [FILE] (try --help for more information)\n", stderr);
1961       exit (2);
1962     }
1963   fputs
1964     ("Usage: " PGM " [OPTIONS] MODE [FILE]\n"
1965      "Run a crypto operation using hex encoded input and output.\n"
1966      "MODE:\n"
1967      "  encrypt, decrypt, digest, random, hmac-sha,\n"
1968      "  rsa-{derive,gen,sign,verify}, dsa-{pqg-gen,gen,sign,verify}\n"
1969      "OPTIONS:\n"
1970      "  --verbose        Print additional information\n"
1971      "  --binary         Input and output is in binary form\n"
1972      "  --no-fips        Do not force FIPS mode\n"
1973      "  --key KEY        Use the hex encoded KEY\n"
1974      "  --iv IV          Use the hex encoded IV\n"
1975      "  --dt DT          Use the hex encoded DT for the RNG\n"
1976      "  --algo NAME      Use algorithm NAME\n"
1977      "  --keysize N      Use a keysize of N bits\n"
1978      "  --signature NAME Take signature from file NAME\n"
1979      "  --chunk N        Read in chunks of N bytes (implies --binary)\n"
1980      "  --pkcs1          Use PKCS#1 encoding\n"
1981      "  --mct-server     Run a monte carlo test server\n"
1982      "  --loop           Enable random loop mode\n"
1983      "  --progress       Print pogress indicators\n"
1984      "  --help           Print this text\n"
1985      "With no FILE, or when FILE is -, read standard input.\n"
1986      "Report bugs to " PACKAGE_BUGREPORT ".\n" , stdout);
1987   exit (0);
1988 }
1989
1990 int
1991 main (int argc, char **argv)
1992 {
1993   int last_argc = -1;
1994   gpg_error_t err;
1995   int no_fips = 0;
1996   int progress = 0;
1997   int use_pkcs1 = 0;
1998   const char *mode_string;
1999   const char *key_string = NULL;
2000   const char *iv_string = NULL;
2001   const char *dt_string = NULL;
2002   const char *algo_string = NULL;
2003   const char *keysize_string = NULL;
2004   const char *signature_string = NULL;
2005   FILE *input;
2006   void *data;
2007   size_t datalen;
2008   size_t chunksize = 0;
2009   int mct_server = 0;
2010
2011
2012   if (argc)
2013     { argc--; argv++; }
2014
2015   while (argc && last_argc != argc )
2016     {
2017       last_argc = argc;
2018       if (!strcmp (*argv, "--"))
2019         {
2020           argc--; argv++;
2021           break;
2022         }
2023       else if (!strcmp (*argv, "--help"))
2024         {
2025           usage (1);
2026         }
2027       else if (!strcmp (*argv, "--version"))
2028         {
2029           fputs (PGM " (Libgcrypt) " PACKAGE_VERSION "\n", stdout);
2030           exit (0);
2031         }
2032       else if (!strcmp (*argv, "--verbose"))
2033         {
2034           verbose++;
2035           argc--; argv++;
2036         }
2037       else if (!strcmp (*argv, "--binary"))
2038         {
2039           binary_input = binary_output = 1;
2040           argc--; argv++;
2041         }
2042       else if (!strcmp (*argv, "--no-fips"))
2043         {
2044           no_fips++;
2045           argc--; argv++;
2046         }
2047       else if (!strcmp (*argv, "--loop"))
2048         {
2049           loop_mode = 1;
2050           argc--; argv++;
2051         }
2052       else if (!strcmp (*argv, "--progress"))
2053         {
2054           progress = 1;
2055           argc--; argv++;
2056         }
2057       else if (!strcmp (*argv, "--key"))
2058         {
2059           argc--; argv++;
2060           if (!argc)
2061             usage (0);
2062           key_string = *argv;
2063           argc--; argv++;
2064         }
2065       else if (!strcmp (*argv, "--iv"))
2066         {
2067           argc--; argv++;
2068           if (!argc)
2069             usage (0);
2070           iv_string = *argv;
2071           argc--; argv++;
2072         }
2073       else if (!strcmp (*argv, "--dt"))
2074         {
2075           argc--; argv++;
2076           if (!argc)
2077             usage (0);
2078           dt_string = *argv;
2079           argc--; argv++;
2080         }
2081       else if (!strcmp (*argv, "--algo"))
2082         {
2083           argc--; argv++;
2084           if (!argc)
2085             usage (0);
2086           algo_string = *argv;
2087           argc--; argv++;
2088         }
2089       else if (!strcmp (*argv, "--keysize"))
2090         {
2091           argc--; argv++;
2092           if (!argc)
2093             usage (0);
2094           keysize_string = *argv;
2095           argc--; argv++;
2096         }
2097       else if (!strcmp (*argv, "--signature"))
2098         {
2099           argc--; argv++;
2100           if (!argc)
2101             usage (0);
2102           signature_string = *argv;
2103           argc--; argv++;
2104         }
2105       else if (!strcmp (*argv, "--chunk"))
2106         {
2107           argc--; argv++;
2108           if (!argc)
2109             usage (0);
2110           chunksize = atoi (*argv);
2111           binary_input = binary_output = 1;
2112           argc--; argv++;
2113         }
2114       else if (!strcmp (*argv, "--pkcs1"))
2115         {
2116           use_pkcs1 = 1;
2117           argc--; argv++;
2118         }
2119       else if (!strcmp (*argv, "--mct-server"))
2120         {
2121           mct_server = 1;
2122           argc--; argv++;
2123         }
2124     }          
2125
2126   if (!argc || argc > 2)
2127     usage (0);
2128   mode_string = *argv;
2129
2130   if (!strcmp (mode_string, "rsa-derive"))
2131     binary_input = 1;
2132
2133   if (argc == 2 && strcmp (argv[1], "-"))
2134     {
2135       input = fopen (argv[1], binary_input? "rb":"r");
2136       if (!input)
2137         die ("can't open `%s': %s\n", argv[1], strerror (errno));
2138     }
2139   else
2140     input = stdin;
2141
2142 #ifndef HAVE_W32_SYSTEM
2143   if (loop_mode)
2144     signal (SIGPIPE, SIG_IGN);
2145 #endif
2146
2147   if (verbose)
2148     fprintf (stderr, PGM ": started (mode=%s)\n", mode_string);
2149
2150   gcry_control (GCRYCTL_SET_VERBOSITY, (int)verbose);
2151   if (!no_fips)
2152     gcry_control (GCRYCTL_FORCE_FIPS_MODE, 0);
2153   if (!gcry_check_version ("1.4.3"))
2154     die ("Libgcrypt is not sufficient enough\n");
2155   if (verbose)
2156     fprintf (stderr, PGM ": using Libgcrypt %s\n", gcry_check_version (NULL));
2157   if (no_fips)
2158     gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
2159   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
2160
2161   /* Most operations need some input data.  */
2162   if (!chunksize
2163       && !mct_server
2164       && strcmp (mode_string, "random")
2165       && strcmp (mode_string, "rsa-gen")
2166       && strcmp (mode_string, "dsa-pqg-gen")
2167       && strcmp (mode_string, "dsa-gen") )
2168     {
2169       data = read_file (input, !binary_input, &datalen);
2170       if (!data)
2171         die ("error reading%s input\n", binary_input?"":" and decoding");
2172       if (verbose)
2173         fprintf (stderr, PGM ": %u bytes of input data\n", 
2174                  (unsigned int)datalen);
2175     }
2176   else
2177     {
2178       data = NULL;
2179       datalen = 0;
2180     }
2181
2182
2183   if (!strcmp (mode_string, "encrypt") || !strcmp (mode_string, "decrypt"))
2184     {
2185       int cipher_algo, cipher_mode;
2186       void  *iv_buffer = NULL;
2187       void *key_buffer = NULL;
2188       size_t iv_buflen,  key_buflen;
2189
2190       if (!algo_string)
2191         die ("option --algo is required in this mode\n");
2192       cipher_algo = map_openssl_cipher_name (algo_string, &cipher_mode);
2193       if (!cipher_algo)
2194         die ("cipher algorithm `%s' is not supported\n", algo_string);
2195       if (mct_server)
2196         {
2197           int iterations;
2198
2199           for (;;)
2200             {
2201               gcry_free (key_buffer); key_buffer = NULL;
2202               gcry_free (iv_buffer); iv_buffer = NULL;
2203               gcry_free (data); data = NULL;
2204               if (!(key_buffer = read_textline (input)))
2205                 {
2206                   if (feof (input))
2207                     break;
2208                   die ("no version info in input\n");
2209                 }
2210               if (atoi (key_buffer) != 1)
2211                 die ("unsupported input version %s\n", key_buffer);
2212               gcry_free (key_buffer);
2213               if (!(key_buffer = read_textline (input)))
2214                 die ("no iteration count in input\n");
2215               iterations = atoi (key_buffer);
2216               gcry_free (key_buffer);
2217               if (!(key_buffer = read_hexline (input, &key_buflen)))
2218                 die ("no key in input\n");
2219               if (!(iv_buffer = read_hexline (input, &iv_buflen)))
2220                 die ("no IV in input\n");
2221               if (!(data = read_hexline (input, &datalen)))
2222                 die ("no data in input\n");
2223               skip_to_empty_line (input);
2224               
2225               run_cipher_mct_loop ((*mode_string == 'e'),
2226                                    cipher_algo, cipher_mode,
2227                                    iv_buffer, iv_buflen,
2228                                    key_buffer, key_buflen,
2229                                    data, datalen, iterations);
2230             }
2231         }
2232       else
2233         {
2234           if (cipher_mode != GCRY_CIPHER_MODE_ECB)
2235             {
2236               if (!iv_string)
2237                 die ("option --iv is required in this mode\n");
2238               iv_buffer = hex2buffer (iv_string, &iv_buflen);
2239               if (!iv_buffer)
2240                 die ("invalid value for IV\n");
2241             }
2242           else
2243             {
2244               iv_buffer = NULL;
2245               iv_buflen = 0;
2246             }
2247           if (!key_string)
2248             die ("option --key is required in this mode\n");
2249           key_buffer = hex2buffer (key_string, &key_buflen);
2250           if (!key_buffer)
2251             die ("invalid value for KEY\n");
2252
2253           run_encrypt_decrypt ((*mode_string == 'e'),
2254                                cipher_algo, cipher_mode,
2255                                iv_buffer, iv_buflen,
2256                                key_buffer, key_buflen,
2257                                data, data? datalen:chunksize, input);
2258         }
2259       gcry_free (key_buffer);
2260       gcry_free (iv_buffer);
2261     }
2262   else if (!strcmp (mode_string, "digest"))
2263     {
2264       int algo;
2265
2266       if (!algo_string)
2267         die ("option --algo is required in this mode\n");
2268       algo = gcry_md_map_name (algo_string);
2269       if (!algo)
2270         die ("digest algorithm `%s' is not supported\n", algo_string);
2271       if (!data)
2272         die ("no data available (do not use --chunk)\n");
2273
2274       run_digest (algo, data, datalen);
2275     }
2276   else if (!strcmp (mode_string, "random"))
2277     {
2278       void *context;
2279       unsigned char key[16];
2280       unsigned char seed[16];
2281       unsigned char dt[16];
2282       unsigned char buffer[16];
2283       size_t count = 0;
2284
2285       if (hex2bin (key_string, key, 16) < 0 )
2286         die ("value for --key are not 32 hex digits\n");
2287       if (hex2bin (iv_string, seed, 16) < 0 )
2288         die ("value for --iv are not 32 hex digits\n");
2289       if (hex2bin (dt_string, dt, 16) < 0 )
2290         die ("value for --dt are not 32 hex digits\n");
2291
2292       /* The flag value 1 disables the dup check, so that the RNG
2293          returns all generated data.  */
2294       err = init_external_rng_test (&context, 1, key, 16, seed, 16, dt, 16);
2295       if (err)
2296         die ("init external RNG test failed: %s\n", gpg_strerror (err));
2297
2298       do 
2299         {
2300           err = run_external_rng_test (context, buffer, sizeof buffer);
2301           if (err)
2302             die ("running external RNG test failed: %s\n", gpg_strerror (err));
2303           print_buffer (buffer, sizeof buffer);
2304           if (progress)
2305             {
2306               if (!(++count % 1000))
2307                 fprintf (stderr, PGM ": %lu random bytes so far\n", 
2308                          (unsigned long int)count * sizeof buffer);
2309             }
2310         }
2311       while (loop_mode);
2312       
2313       if (progress)
2314         fprintf (stderr, PGM ": %lu random bytes\n",
2315                          (unsigned long int)count * sizeof buffer);
2316
2317       deinit_external_rng_test (context);
2318     }
2319   else if (!strcmp (mode_string, "hmac-sha"))
2320     {
2321       int algo;
2322       void  *key_buffer;
2323       size_t key_buflen;
2324
2325       if (!data)
2326         die ("no data available (do not use --chunk)\n");
2327       if (!algo_string)
2328         die ("option --algo is required in this mode\n");
2329       switch (atoi (algo_string))
2330         {
2331         case 1:   algo = GCRY_MD_SHA1; break;
2332         case 224: algo = GCRY_MD_SHA224; break;
2333         case 256: algo = GCRY_MD_SHA256; break;
2334         case 384: algo = GCRY_MD_SHA384; break;
2335         case 512: algo = GCRY_MD_SHA512; break;
2336         default:  algo = 0; break;
2337         }
2338       if (!algo)
2339         die ("no digest algorithm found for hmac type `%s'\n", algo_string);
2340       if (!key_string)
2341         die ("option --key is required in this mode\n");
2342       key_buffer = hex2buffer (key_string, &key_buflen);
2343       if (!key_buffer)
2344         die ("invalid value for KEY\n");
2345
2346       run_hmac (algo, key_buffer, key_buflen, data, datalen);
2347
2348       gcry_free (key_buffer);
2349     }
2350   else if (!strcmp (mode_string, "rsa-derive"))
2351     {
2352       if (!data)
2353         die ("no data available (do not use --chunk)\n");
2354       run_rsa_derive (data, datalen);
2355     }
2356   else if (!strcmp (mode_string, "rsa-gen"))
2357     {
2358       int keysize;
2359       
2360       if (!binary_output)
2361         base64_output = 1;
2362
2363       keysize = keysize_string? atoi (keysize_string) : 0;
2364       if (keysize < 128 || keysize > 16384)
2365         die ("invalid keysize specified; needs to be 128 .. 16384\n");
2366       run_rsa_gen (keysize, 65537);
2367     }
2368   else if (!strcmp (mode_string, "rsa-sign"))
2369     {
2370       int algo;
2371
2372       if (!key_string)
2373         die ("option --key is required in this mode\n");
2374       if (access (key_string, R_OK))
2375         die ("option --key needs to specify an existing keyfile\n");
2376       if (!algo_string)
2377         die ("option --algo is required in this mode\n");
2378       algo = gcry_md_map_name (algo_string);
2379       if (!algo)
2380         die ("digest algorithm `%s' is not supported\n", algo_string);
2381       if (!data)
2382         die ("no data available (do not use --chunk)\n");
2383
2384       run_rsa_sign (data, datalen, algo, use_pkcs1, key_string);
2385
2386     }
2387   else if (!strcmp (mode_string, "rsa-verify"))
2388     {
2389       int algo;
2390
2391       if (!key_string)
2392         die ("option --key is required in this mode\n");
2393       if (access (key_string, R_OK))
2394         die ("option --key needs to specify an existing keyfile\n");
2395       if (!algo_string)
2396         die ("option --algo is required in this mode\n");
2397       algo = gcry_md_map_name (algo_string);
2398       if (!algo)
2399         die ("digest algorithm `%s' is not supported\n", algo_string);
2400       if (!data)
2401         die ("no data available (do not use --chunk)\n");
2402       if (!signature_string)
2403         die ("option --signature is required in this mode\n");
2404       if (access (signature_string, R_OK))
2405         die ("option --signature needs to specify an existing file\n");
2406
2407       run_rsa_verify (data, datalen, algo, use_pkcs1, key_string,
2408                       signature_string);
2409
2410     }
2411   else if (!strcmp (mode_string, "dsa-pqg-gen"))
2412     {
2413       int keysize;
2414       
2415       keysize = keysize_string? atoi (keysize_string) : 0;
2416       if (keysize < 1024 || keysize > 3072)
2417         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2418       run_dsa_pqg_gen (keysize);
2419     }
2420   else if (!strcmp (mode_string, "dsa-gen"))
2421     {
2422       int keysize;
2423       
2424       keysize = keysize_string? atoi (keysize_string) : 0;
2425       if (keysize < 1024 || keysize > 3072)
2426         die ("invalid keysize specified; needs to be 1024 .. 3072\n");
2427       if (!key_string)
2428         die ("option --key is required in this mode\n");
2429       run_dsa_gen (keysize, key_string);
2430     }
2431   else if (!strcmp (mode_string, "dsa-sign"))
2432     {
2433       if (!key_string)
2434         die ("option --key is required in this mode\n");
2435       if (access (key_string, R_OK))
2436         die ("option --key needs to specify an existing keyfile\n");
2437       if (!data)
2438         die ("no data available (do not use --chunk)\n");
2439
2440       run_dsa_sign (data, datalen, key_string);
2441     }
2442   else if (!strcmp (mode_string, "dsa-verify"))
2443     {
2444       if (!key_string)
2445         die ("option --key is required in this mode\n");
2446       if (access (key_string, R_OK))
2447         die ("option --key needs to specify an existing keyfile\n");
2448       if (!data)
2449         die ("no data available (do not use --chunk)\n");
2450       if (!signature_string)
2451         die ("option --signature is required in this mode\n");
2452       if (access (signature_string, R_OK))
2453         die ("option --signature needs to specify an existing file\n");
2454
2455       run_dsa_verify (data, datalen, key_string, signature_string);
2456     }
2457   else
2458     usage (0);
2459
2460   gcry_free (data);
2461
2462   /* Because Libgcrypt does not enforce FIPS mode in all cases we let
2463      the process die if Libgcrypt is not anymore in FIPS mode after
2464      the actual operation.  */
2465   if (!no_fips && !gcry_fips_mode_active ())
2466     die ("FIPS mode is not anymore active\n");
2467
2468   if (verbose)
2469     fputs (PGM ": ready\n", stderr);
2470
2471   return 0;
2472 }
2473