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