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