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