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